// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <utility>

#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/macros.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/threading/platform_thread.h"
#include "net/base/completion_callback.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/base/test_completion_callback.h"
#include "net/disk_cache/blockfile/backend_impl.h"
#include "net/disk_cache/blockfile/entry_impl.h"
#include "net/disk_cache/disk_cache_test_base.h"
#include "net/disk_cache/disk_cache_test_util.h"
#include "net/disk_cache/memory/mem_entry_impl.h"
#include "net/disk_cache/simple/simple_backend_impl.h"
#include "net/disk_cache/simple/simple_entry_format.h"
#include "net/disk_cache/simple/simple_entry_impl.h"
#include "net/disk_cache/simple/simple_synchronous_entry.h"
#include "net/disk_cache/simple/simple_test_util.h"
#include "net/disk_cache/simple/simple_util.h"
#include "testing/gtest/include/gtest/gtest.h"

using base::Time;
using disk_cache::ScopedEntryPtr;

// Tests that can run with different types of caches.
class DiskCacheEntryTest : public DiskCacheTestWithCache {
public:
    void InternalSyncIOBackground(disk_cache::Entry* entry);
    void ExternalSyncIOBackground(disk_cache::Entry* entry);

protected:
    void InternalSyncIO();
    void InternalAsyncIO();
    void ExternalSyncIO();
    void ExternalAsyncIO();
    void ReleaseBuffer(int stream_index);
    void StreamAccess();
    void GetKey();
    void GetTimes(int stream_index);
    void GrowData(int stream_index);
    void TruncateData(int stream_index);
    void ZeroLengthIO(int stream_index);
    void Buffering();
    void SizeAtCreate();
    void SizeChanges(int stream_index);
    void ReuseEntry(int size, int stream_index);
    void InvalidData(int stream_index);
    void ReadWriteDestroyBuffer(int stream_index);
    void DoomNormalEntry();
    void DoomEntryNextToOpenEntry();
    void DoomedEntry(int stream_index);
    void BasicSparseIO();
    void HugeSparseIO();
    void GetAvailableRange();
    void CouldBeSparse();
    void UpdateSparseEntry();
    void DoomSparseEntry();
    void PartialSparseEntry();
    bool SimpleCacheMakeBadChecksumEntry(const std::string& key, int* data_size);
    bool SimpleCacheThirdStreamFileExists(const char* key);
    void SyncDoomEntry(const char* key);
};

// This part of the test runs on the background thread.
void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry)
{
    const int kSize1 = 10;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    EXPECT_EQ(
        0,
        entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
    base::strlcpy(buffer1->data(), "the data", kSize1);
    EXPECT_EQ(10,
        entry->WriteData(
            0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
    memset(buffer1->data(), 0, kSize1);
    EXPECT_EQ(
        10,
        entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
    EXPECT_STREQ("the data", buffer1->data());

    const int kSize2 = 5000;
    const int kSize3 = 10000;
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
    scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
    memset(buffer3->data(), 0, kSize3);
    CacheTestFillBuffer(buffer2->data(), kSize2, false);
    base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
    EXPECT_EQ(
        5000,
        entry->WriteData(
            1, 1500, buffer2.get(), kSize2, net::CompletionCallback(), false));
    memset(buffer2->data(), 0, kSize2);
    EXPECT_EQ(4989,
        entry->ReadData(
            1, 1511, buffer2.get(), kSize2, net::CompletionCallback()));
    EXPECT_STREQ("big data goes here", buffer2->data());
    EXPECT_EQ(
        5000,
        entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
    EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
    EXPECT_EQ(1500,
        entry->ReadData(
            1, 5000, buffer2.get(), kSize2, net::CompletionCallback()));

    EXPECT_EQ(0,
        entry->ReadData(
            1, 6500, buffer2.get(), kSize2, net::CompletionCallback()));
    EXPECT_EQ(
        6500,
        entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
    EXPECT_EQ(8192,
        entry->WriteData(
            1, 0, buffer3.get(), 8192, net::CompletionCallback(), false));
    EXPECT_EQ(
        8192,
        entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback()));
    EXPECT_EQ(8192, entry->GetDataSize(1));

    // We need to delete the memory buffer on this thread.
    EXPECT_EQ(0, entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
    EXPECT_EQ(0, entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
}

// We need to support synchronous IO even though it is not a supported operation
// from the point of view of the disk cache's public interface, because we use
// it internally, not just by a few tests, but as part of the implementation
// (see sparse_control.cc, for example).
void DiskCacheEntryTest::InternalSyncIO()
{
    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
    ASSERT_TRUE(NULL != entry);

    // The bulk of the test runs from within the callback, on the cache thread.
    RunTaskForTest(base::Bind(&DiskCacheEntryTest::InternalSyncIOBackground,
        base::Unretained(this),
        entry));

    entry->Doom();
    entry->Close();
    FlushQueueForTest();
    EXPECT_EQ(0, cache_->GetEntryCount());
}

TEST_F(DiskCacheEntryTest, InternalSyncIO)
{
    InitCache();
    InternalSyncIO();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO)
{
    SetMemoryOnlyMode();
    InitCache();
    InternalSyncIO();
}

void DiskCacheEntryTest::InternalAsyncIO()
{
    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
    ASSERT_TRUE(NULL != entry);

    // Avoid using internal buffers for the test. We have to write something to
    // the entry and close it so that we flush the internal buffer to disk. After
    // that, IO operations will be really hitting the disk. We don't care about
    // the content, so just extending the entry is enough (all extensions zero-
    // fill any holes).
    EXPECT_EQ(0, WriteData(entry, 0, 15 * 1024, NULL, 0, false));
    EXPECT_EQ(0, WriteData(entry, 1, 15 * 1024, NULL, 0, false));
    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));

    MessageLoopHelper helper;
    // Let's verify that each IO goes to the right callback object.
    CallbackTest callback1(&helper, false);
    CallbackTest callback2(&helper, false);
    CallbackTest callback3(&helper, false);
    CallbackTest callback4(&helper, false);
    CallbackTest callback5(&helper, false);
    CallbackTest callback6(&helper, false);
    CallbackTest callback7(&helper, false);
    CallbackTest callback8(&helper, false);
    CallbackTest callback9(&helper, false);
    CallbackTest callback10(&helper, false);
    CallbackTest callback11(&helper, false);
    CallbackTest callback12(&helper, false);
    CallbackTest callback13(&helper, false);

    const int kSize1 = 10;
    const int kSize2 = 5000;
    const int kSize3 = 10000;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
    scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    CacheTestFillBuffer(buffer2->data(), kSize2, false);
    CacheTestFillBuffer(buffer3->data(), kSize3, false);

    EXPECT_EQ(0,
        entry->ReadData(
            0,
            15 * 1024,
            buffer1.get(),
            kSize1,
            base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
    base::strlcpy(buffer1->data(), "the data", kSize1);
    int expected = 0;
    int ret = entry->WriteData(
        0,
        0,
        buffer1.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
        false);
    EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    memset(buffer2->data(), 0, kSize2);
    ret = entry->ReadData(
        0,
        0,
        buffer2.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback3)));
    EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_STREQ("the data", buffer2->data());

    base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
    ret = entry->WriteData(
        1,
        1500,
        buffer2.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
        true);
    EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    memset(buffer3->data(), 0, kSize3);
    ret = entry->ReadData(
        1,
        1511,
        buffer3.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
    EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_STREQ("big data goes here", buffer3->data());
    ret = entry->ReadData(
        1,
        0,
        buffer2.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
    EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    memset(buffer3->data(), 0, kSize3);

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
    ret = entry->ReadData(
        1,
        5000,
        buffer2.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback7)));
    EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    ret = entry->ReadData(
        1,
        0,
        buffer3.get(),
        kSize3,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback9)));
    EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    ret = entry->WriteData(
        1,
        0,
        buffer3.get(),
        8192,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback10)),
        true);
    EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    ret = entry->ReadData(
        1,
        0,
        buffer3.get(),
        kSize3,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback11)));
    EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_EQ(8192, entry->GetDataSize(1));

    ret = entry->ReadData(
        0,
        0,
        buffer1.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback12)));
    EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    ret = entry->ReadData(
        1,
        0,
        buffer2.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback13)));
    EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));

    EXPECT_FALSE(helper.callback_reused_error());

    entry->Doom();
    entry->Close();
    FlushQueueForTest();
    EXPECT_EQ(0, cache_->GetEntryCount());
}

TEST_F(DiskCacheEntryTest, InternalAsyncIO)
{
    InitCache();
    InternalAsyncIO();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO)
{
    SetMemoryOnlyMode();
    InitCache();
    InternalAsyncIO();
}

// This part of the test runs on the background thread.
void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry)
{
    const int kSize1 = 17000;
    const int kSize2 = 25000;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    CacheTestFillBuffer(buffer2->data(), kSize2, false);
    base::strlcpy(buffer1->data(), "the data", kSize1);
    EXPECT_EQ(17000,
        entry->WriteData(
            0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
    memset(buffer1->data(), 0, kSize1);
    EXPECT_EQ(
        17000,
        entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
    EXPECT_STREQ("the data", buffer1->data());

    base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
    EXPECT_EQ(
        25000,
        entry->WriteData(
            1, 10000, buffer2.get(), kSize2, net::CompletionCallback(), false));
    memset(buffer2->data(), 0, kSize2);
    EXPECT_EQ(24989,
        entry->ReadData(
            1, 10011, buffer2.get(), kSize2, net::CompletionCallback()));
    EXPECT_STREQ("big data goes here", buffer2->data());
    EXPECT_EQ(
        25000,
        entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback()));
    EXPECT_EQ(5000,
        entry->ReadData(
            1, 30000, buffer2.get(), kSize2, net::CompletionCallback()));

    EXPECT_EQ(0,
        entry->ReadData(
            1, 35000, buffer2.get(), kSize2, net::CompletionCallback()));
    EXPECT_EQ(
        17000,
        entry->ReadData(1, 0, buffer1.get(), kSize1, net::CompletionCallback()));
    EXPECT_EQ(
        17000,
        entry->WriteData(
            1, 20000, buffer1.get(), kSize1, net::CompletionCallback(), false));
    EXPECT_EQ(37000, entry->GetDataSize(1));

    // We need to delete the memory buffer on this thread.
    EXPECT_EQ(0, entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
    EXPECT_EQ(0, entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
}

void DiskCacheEntryTest::ExternalSyncIO()
{
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));

    // The bulk of the test runs from within the callback, on the cache thread.
    RunTaskForTest(base::Bind(&DiskCacheEntryTest::ExternalSyncIOBackground,
        base::Unretained(this),
        entry));

    entry->Doom();
    entry->Close();
    FlushQueueForTest();
    EXPECT_EQ(0, cache_->GetEntryCount());
}

TEST_F(DiskCacheEntryTest, ExternalSyncIO)
{
    InitCache();
    ExternalSyncIO();
}

TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    ExternalSyncIO();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO)
{
    SetMemoryOnlyMode();
    InitCache();
    ExternalSyncIO();
}

void DiskCacheEntryTest::ExternalAsyncIO()
{
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));

    int expected = 0;

    MessageLoopHelper helper;
    // Let's verify that each IO goes to the right callback object.
    CallbackTest callback1(&helper, false);
    CallbackTest callback2(&helper, false);
    CallbackTest callback3(&helper, false);
    CallbackTest callback4(&helper, false);
    CallbackTest callback5(&helper, false);
    CallbackTest callback6(&helper, false);
    CallbackTest callback7(&helper, false);
    CallbackTest callback8(&helper, false);
    CallbackTest callback9(&helper, false);

    const int kSize1 = 17000;
    const int kSize2 = 25000;
    const int kSize3 = 25000;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
    scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    CacheTestFillBuffer(buffer2->data(), kSize2, false);
    CacheTestFillBuffer(buffer3->data(), kSize3, false);
    base::strlcpy(buffer1->data(), "the data", kSize1);
    int ret = entry->WriteData(
        0,
        0,
        buffer1.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback1)),
        false);
    EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));

    memset(buffer2->data(), 0, kSize1);
    ret = entry->ReadData(
        0,
        0,
        buffer2.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback2)));
    EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_STREQ("the data", buffer2->data());

    base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
    ret = entry->WriteData(
        1,
        10000,
        buffer2.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback3)),
        false);
    EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));

    memset(buffer3->data(), 0, kSize3);
    ret = entry->ReadData(
        1,
        10011,
        buffer3.get(),
        kSize3,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback4)));
    EXPECT_TRUE(24989 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_STREQ("big data goes here", buffer3->data());
    ret = entry->ReadData(
        1,
        0,
        buffer2.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
    EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    memset(buffer3->data(), 0, kSize3);
    EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 10000));
    ret = entry->ReadData(
        1,
        30000,
        buffer2.get(),
        kSize2,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
    EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_EQ(0,
        entry->ReadData(
            1,
            35000,
            buffer2.get(),
            kSize2,
            base::Bind(&CallbackTest::Run, base::Unretained(&callback7))));
    ret = entry->ReadData(
        1,
        0,
        buffer1.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback8)));
    EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;
    ret = entry->WriteData(
        1,
        20000,
        buffer3.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback9)),
        false);
    EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_EQ(37000, entry->GetDataSize(1));

    EXPECT_FALSE(helper.callback_reused_error());

    entry->Doom();
    entry->Close();
    FlushQueueForTest();
    EXPECT_EQ(0, cache_->GetEntryCount());
}

TEST_F(DiskCacheEntryTest, ExternalAsyncIO)
{
    InitCache();
    ExternalAsyncIO();
}

// TODO(http://crbug.com/497101): This test is flaky.
#if defined(OS_IOS)
#define MAYBE_ExternalAsyncIONoBuffer DISABLED_ExternalAsyncIONoBuffer
#else
#define MAYBE_ExternalAsyncIONoBuffer ExternalAsyncIONoBuffer
#endif
TEST_F(DiskCacheEntryTest, MAYBE_ExternalAsyncIONoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    ExternalAsyncIO();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO)
{
    SetMemoryOnlyMode();
    InitCache();
    ExternalAsyncIO();
}

// Tests that IOBuffers are not referenced after IO completes.
void DiskCacheEntryTest::ReleaseBuffer(int stream_index)
{
    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
    ASSERT_TRUE(NULL != entry);

    const int kBufferSize = 1024;
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
    CacheTestFillBuffer(buffer->data(), kBufferSize, false);

    net::ReleaseBufferCompletionCallback cb(buffer.get());
    int rv = entry->WriteData(
        stream_index, 0, buffer.get(), kBufferSize, cb.callback(), false);
    EXPECT_EQ(kBufferSize, cb.GetResult(rv));
    entry->Close();
}

TEST_F(DiskCacheEntryTest, ReleaseBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    ReleaseBuffer(0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer)
{
    SetMemoryOnlyMode();
    InitCache();
    ReleaseBuffer(0);
}

void DiskCacheEntryTest::StreamAccess()
{
    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry("the first key", &entry));
    ASSERT_TRUE(NULL != entry);

    const int kBufferSize = 1024;
    const int kNumStreams = 3;
    scoped_refptr<net::IOBuffer> reference_buffers[kNumStreams];
    for (int i = 0; i < kNumStreams; i++) {
        reference_buffers[i] = new net::IOBuffer(kBufferSize);
        CacheTestFillBuffer(reference_buffers[i]->data(), kBufferSize, false);
    }
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize));
    for (int i = 0; i < kNumStreams; i++) {
        EXPECT_EQ(
            kBufferSize,
            WriteData(entry, i, 0, reference_buffers[i].get(), kBufferSize, false));
        memset(buffer1->data(), 0, kBufferSize);
        EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize));
        EXPECT_EQ(
            0, memcmp(reference_buffers[i]->data(), buffer1->data(), kBufferSize));
    }
    EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
        ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize));
    entry->Close();

    // Open the entry and read it in chunks, including a read past the end.
    ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
    ASSERT_TRUE(NULL != entry);
    const int kReadBufferSize = 600;
    const int kFinalReadSize = kBufferSize - kReadBufferSize;
    static_assert(kFinalReadSize < kReadBufferSize,
        "should be exactly two reads");
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kReadBufferSize));
    for (int i = 0; i < kNumStreams; i++) {
        memset(buffer2->data(), 0, kReadBufferSize);
        EXPECT_EQ(kReadBufferSize,
            ReadData(entry, i, 0, buffer2.get(), kReadBufferSize));
        EXPECT_EQ(
            0,
            memcmp(reference_buffers[i]->data(), buffer2->data(), kReadBufferSize));

        memset(buffer2->data(), 0, kReadBufferSize);
        EXPECT_EQ(
            kFinalReadSize,
            ReadData(entry, i, kReadBufferSize, buffer2.get(), kReadBufferSize));
        EXPECT_EQ(0,
            memcmp(reference_buffers[i]->data() + kReadBufferSize,
                buffer2->data(),
                kFinalReadSize));
    }

    entry->Close();
}

TEST_F(DiskCacheEntryTest, StreamAccess)
{
    InitCache();
    StreamAccess();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess)
{
    SetMemoryOnlyMode();
    InitCache();
    StreamAccess();
}

void DiskCacheEntryTest::GetKey()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_EQ(key, entry->GetKey()) << "short key";
    entry->Close();

    int seed = static_cast<int>(Time::Now().ToInternalValue());
    srand(seed);
    char key_buffer[20000];

    CacheTestFillBuffer(key_buffer, 3000, true);
    key_buffer[1000] = '\0';

    key = key_buffer;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key";
    entry->Close();

    key_buffer[1000] = 'p';
    key_buffer[3000] = '\0';
    key = key_buffer;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_TRUE(key == entry->GetKey()) << "medium size key";
    entry->Close();

    CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true);
    key_buffer[19999] = '\0';

    key = key_buffer;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_TRUE(key == entry->GetKey()) << "long key";
    entry->Close();

    CacheTestFillBuffer(key_buffer, 0x4000, true);
    key_buffer[0x4000] = '\0';

    key = key_buffer;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_TRUE(key == entry->GetKey()) << "16KB key";
    entry->Close();
}

TEST_F(DiskCacheEntryTest, GetKey)
{
    InitCache();
    GetKey();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey)
{
    SetMemoryOnlyMode();
    InitCache();
    GetKey();
}

void DiskCacheEntryTest::GetTimes(int stream_index)
{
    std::string key("the first key");
    disk_cache::Entry* entry;

    Time t1 = Time::Now();
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_TRUE(entry->GetLastModified() >= t1);
    EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());

    AddDelay();
    Time t2 = Time::Now();
    EXPECT_TRUE(t2 > t1);
    EXPECT_EQ(0, WriteData(entry, stream_index, 200, NULL, 0, false));
    if (type_ == net::APP_CACHE) {
        EXPECT_TRUE(entry->GetLastModified() < t2);
    } else {
        EXPECT_TRUE(entry->GetLastModified() >= t2);
    }
    EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed());

    AddDelay();
    Time t3 = Time::Now();
    EXPECT_TRUE(t3 > t2);
    const int kSize = 200;
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 0, buffer.get(), kSize));
    if (type_ == net::APP_CACHE) {
        EXPECT_TRUE(entry->GetLastUsed() < t2);
        EXPECT_TRUE(entry->GetLastModified() < t2);
    } else if (type_ == net::SHADER_CACHE) {
        EXPECT_TRUE(entry->GetLastUsed() < t3);
        EXPECT_TRUE(entry->GetLastModified() < t3);
    } else {
        EXPECT_TRUE(entry->GetLastUsed() >= t3);
        EXPECT_TRUE(entry->GetLastModified() < t3);
    }
    entry->Close();
}

TEST_F(DiskCacheEntryTest, GetTimes)
{
    InitCache();
    GetTimes(0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyGetTimes)
{
    SetMemoryOnlyMode();
    InitCache();
    GetTimes(0);
}

TEST_F(DiskCacheEntryTest, AppCacheGetTimes)
{
    SetCacheType(net::APP_CACHE);
    InitCache();
    GetTimes(0);
}

TEST_F(DiskCacheEntryTest, ShaderCacheGetTimes)
{
    SetCacheType(net::SHADER_CACHE);
    InitCache();
    GetTimes(0);
}

void DiskCacheEntryTest::GrowData(int stream_index)
{
    std::string key1("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key1, &entry));

    const int kSize = 20000;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kSize, false);
    memset(buffer2->data(), 0, kSize);

    base::strlcpy(buffer1->data(), "the data", kSize);
    EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false));
    EXPECT_EQ(10, ReadData(entry, stream_index, 0, buffer2.get(), 10));
    EXPECT_STREQ("the data", buffer2->data());
    EXPECT_EQ(10, entry->GetDataSize(stream_index));

    EXPECT_EQ(2000,
        WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
    EXPECT_EQ(2000, entry->GetDataSize(stream_index));
    EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
    EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));

    EXPECT_EQ(20000,
        WriteData(entry, stream_index, 0, buffer1.get(), kSize, false));
    EXPECT_EQ(20000, entry->GetDataSize(stream_index));
    EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
    entry->Close();

    memset(buffer2->data(), 0, kSize);
    std::string key2("Second key");
    ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
    EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false));
    EXPECT_EQ(10, entry->GetDataSize(stream_index));
    entry->Close();

    // Go from an internal address to a bigger block size.
    ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
    EXPECT_EQ(2000,
        WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
    EXPECT_EQ(2000, entry->GetDataSize(stream_index));
    EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
    EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
    entry->Close();
    memset(buffer2->data(), 0, kSize);

    // Go from an internal address to an external one.
    ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
    EXPECT_EQ(20000,
        WriteData(entry, stream_index, 0, buffer1.get(), kSize, false));
    EXPECT_EQ(20000, entry->GetDataSize(stream_index));
    EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
    entry->Close();

    // Double check the size from disk.
    ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
    EXPECT_EQ(20000, entry->GetDataSize(stream_index));

    // Now extend the entry without actual data.
    EXPECT_EQ(0, WriteData(entry, stream_index, 45500, buffer1.get(), 0, false));
    entry->Close();

    // And check again from disk.
    ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
    EXPECT_EQ(45500, entry->GetDataSize(stream_index));
    entry->Close();
}

TEST_F(DiskCacheEntryTest, GrowData)
{
    InitCache();
    GrowData(0);
}

TEST_F(DiskCacheEntryTest, GrowDataNoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    GrowData(0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData)
{
    SetMemoryOnlyMode();
    InitCache();
    GrowData(0);
}

void DiskCacheEntryTest::TruncateData(int stream_index)
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize1 = 20000;
    const int kSize2 = 20000;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));

    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    memset(buffer2->data(), 0, kSize2);

    // Simple truncation:
    EXPECT_EQ(200, WriteData(entry, stream_index, 0, buffer1.get(), 200, false));
    EXPECT_EQ(200, entry->GetDataSize(stream_index));
    EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, false));
    EXPECT_EQ(200, entry->GetDataSize(stream_index));
    EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, true));
    EXPECT_EQ(100, entry->GetDataSize(stream_index));
    EXPECT_EQ(0, WriteData(entry, stream_index, 50, buffer1.get(), 0, true));
    EXPECT_EQ(50, entry->GetDataSize(stream_index));
    EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer1.get(), 0, true));
    EXPECT_EQ(0, entry->GetDataSize(stream_index));
    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));

    // Go to an external file.
    EXPECT_EQ(20000,
        WriteData(entry, stream_index, 0, buffer1.get(), 20000, true));
    EXPECT_EQ(20000, entry->GetDataSize(stream_index));
    EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), 20000));
    EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000));
    memset(buffer2->data(), 0, kSize2);

    // External file truncation
    EXPECT_EQ(18000,
        WriteData(entry, stream_index, 0, buffer1.get(), 18000, false));
    EXPECT_EQ(20000, entry->GetDataSize(stream_index));
    EXPECT_EQ(18000,
        WriteData(entry, stream_index, 0, buffer1.get(), 18000, true));
    EXPECT_EQ(18000, entry->GetDataSize(stream_index));
    EXPECT_EQ(0, WriteData(entry, stream_index, 17500, buffer1.get(), 0, true));
    EXPECT_EQ(17500, entry->GetDataSize(stream_index));

    // And back to an internal block.
    EXPECT_EQ(600,
        WriteData(entry, stream_index, 1000, buffer1.get(), 600, true));
    EXPECT_EQ(1600, entry->GetDataSize(stream_index));
    EXPECT_EQ(600, ReadData(entry, stream_index, 1000, buffer2.get(), 600));
    EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600));
    EXPECT_EQ(1000, ReadData(entry, stream_index, 0, buffer2.get(), 1000));
    EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000))
        << "Preserves previous data";

    // Go from external file to zero length.
    EXPECT_EQ(20000,
        WriteData(entry, stream_index, 0, buffer1.get(), 20000, true));
    EXPECT_EQ(20000, entry->GetDataSize(stream_index));
    EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer1.get(), 0, true));
    EXPECT_EQ(0, entry->GetDataSize(stream_index));

    entry->Close();
}

TEST_F(DiskCacheEntryTest, TruncateData)
{
    InitCache();
    TruncateData(0);
}

TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    TruncateData(0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData)
{
    SetMemoryOnlyMode();
    InitCache();
    TruncateData(0);
}

void DiskCacheEntryTest::ZeroLengthIO(int stream_index)
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    EXPECT_EQ(0, ReadData(entry, stream_index, 0, NULL, 0));
    EXPECT_EQ(0, WriteData(entry, stream_index, 0, NULL, 0, false));

    // This write should extend the entry.
    EXPECT_EQ(0, WriteData(entry, stream_index, 1000, NULL, 0, false));
    EXPECT_EQ(0, ReadData(entry, stream_index, 500, NULL, 0));
    EXPECT_EQ(0, ReadData(entry, stream_index, 2000, NULL, 0));
    EXPECT_EQ(1000, entry->GetDataSize(stream_index));

    EXPECT_EQ(0, WriteData(entry, stream_index, 100000, NULL, 0, true));
    EXPECT_EQ(0, ReadData(entry, stream_index, 50000, NULL, 0));
    EXPECT_EQ(100000, entry->GetDataSize(stream_index));

    // Let's verify the actual content.
    const int kSize = 20;
    const char zeros[kSize] = {};
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));

    CacheTestFillBuffer(buffer->data(), kSize, false);
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 500, buffer.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));

    CacheTestFillBuffer(buffer->data(), kSize, false);
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 5000, buffer.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));

    CacheTestFillBuffer(buffer->data(), kSize, false);
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 50000, buffer.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));

    entry->Close();
}

TEST_F(DiskCacheEntryTest, ZeroLengthIO)
{
    InitCache();
    ZeroLengthIO(0);
}

TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    ZeroLengthIO(0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO)
{
    SetMemoryOnlyMode();
    InitCache();
    ZeroLengthIO(0);
}

// Tests that we handle the content correctly when buffering, a feature of the
// standard cache that permits fast responses to certain reads.
void DiskCacheEntryTest::Buffering()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 200;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kSize, true);
    CacheTestFillBuffer(buffer2->data(), kSize, true);

    EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
    entry->Close();

    // Write a little more and read what we wrote before.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false));
    EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));

    // Now go to an external file.
    EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false));
    entry->Close();

    // Write something else and verify old data.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));

    // Extend the file some more.
    EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false));
    entry->Close();

    // And now make sure that we can deal with data in both places (ram/disk).
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false));

    // We should not overwrite the data at 18000 with this.
    EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));

    EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1.get(), kSize, false));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));

    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));

    // Extend the file again and read before without closing the entry.
    EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, false));
    EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1.get(), kSize, false));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));

    entry->Close();
}

TEST_F(DiskCacheEntryTest, Buffering)
{
    InitCache();
    Buffering();
}

TEST_F(DiskCacheEntryTest, BufferingNoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    Buffering();
}

// Checks that entries are zero length when created.
void DiskCacheEntryTest::SizeAtCreate()
{
    const char key[] = "the first key";
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kNumStreams = 3;
    for (int i = 0; i < kNumStreams; ++i)
        EXPECT_EQ(0, entry->GetDataSize(i));
    entry->Close();
}

TEST_F(DiskCacheEntryTest, SizeAtCreate)
{
    InitCache();
    SizeAtCreate();
}

TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate)
{
    SetMemoryOnlyMode();
    InitCache();
    SizeAtCreate();
}

// Some extra tests to make sure that buffering works properly when changing
// the entry size.
void DiskCacheEntryTest::SizeChanges(int stream_index)
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 200;
    const char zeros[kSize] = {};
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kSize, true);
    CacheTestFillBuffer(buffer2->data(), kSize, true);

    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 0, buffer1.get(), kSize, true));
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 17000, buffer1.get(), kSize, true));
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 23000, buffer1.get(), kSize, true));
    entry->Close();

    // Extend the file and read between the old size and the new write.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(23000 + kSize, entry->GetDataSize(stream_index));
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 25000, buffer1.get(), kSize, true));
    EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index));
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 24000, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize));

    // Read at the end of the old file size.
    EXPECT_EQ(
        kSize,
        ReadData(entry, stream_index, 23000 + kSize - 35, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 35, 35));

    // Read slightly before the last write.
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 24900, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
    EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));

    // Extend the entry a little more.
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 26000, buffer1.get(), kSize, true));
    EXPECT_EQ(26000 + kSize, entry->GetDataSize(stream_index));
    CacheTestFillBuffer(buffer2->data(), kSize, true);
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 25900, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
    EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));

    // And now reduce the size.
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 25000, buffer1.get(), kSize, true));
    EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index));
    EXPECT_EQ(
        28,
        ReadData(entry, stream_index, 25000 + kSize - 28, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 28, 28));

    // Reduce the size with a buffer that is not extending the size.
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 24000, buffer1.get(), kSize, false));
    EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index));
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 24500, buffer1.get(), kSize, true));
    EXPECT_EQ(24500 + kSize, entry->GetDataSize(stream_index));
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 23900, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
    EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));

    // And now reduce the size below the old size.
    EXPECT_EQ(kSize,
        WriteData(entry, stream_index, 19000, buffer1.get(), kSize, true));
    EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index));
    EXPECT_EQ(kSize, ReadData(entry, stream_index, 18900, buffer2.get(), kSize));
    EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
    EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));

    // Verify that the actual file is truncated.
    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index));

    // Extend the newly opened file with a zero length write, expect zero fill.
    EXPECT_EQ(
        0,
        WriteData(entry, stream_index, 20000 + kSize, buffer1.get(), 0, false));
    EXPECT_EQ(kSize,
        ReadData(entry, stream_index, 19000 + kSize, buffer1.get(), kSize));
    EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize));

    entry->Close();
}

TEST_F(DiskCacheEntryTest, SizeChanges)
{
    InitCache();
    SizeChanges(1);
}

TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    SizeChanges(1);
}

// Write more than the total cache capacity but to a single entry. |size| is the
// amount of bytes to write each time.
void DiskCacheEntryTest::ReuseEntry(int size, int stream_index)
{
    std::string key1("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key1, &entry));

    entry->Close();
    std::string key2("the second key");
    ASSERT_EQ(net::OK, CreateEntry(key2, &entry));

    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
    CacheTestFillBuffer(buffer->data(), size, false);

    for (int i = 0; i < 15; i++) {
        EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer.get(), 0, true));
        EXPECT_EQ(size,
            WriteData(entry, stream_index, 0, buffer.get(), size, false));
        entry->Close();
        ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
    }

    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry";
    entry->Close();
}

TEST_F(DiskCacheEntryTest, ReuseExternalEntry)
{
    SetMaxSize(200 * 1024);
    InitCache();
    ReuseEntry(20 * 1024, 0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry)
{
    SetMemoryOnlyMode();
    SetMaxSize(200 * 1024);
    InitCache();
    ReuseEntry(20 * 1024, 0);
}

TEST_F(DiskCacheEntryTest, ReuseInternalEntry)
{
    SetMaxSize(100 * 1024);
    InitCache();
    ReuseEntry(10 * 1024, 0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry)
{
    SetMemoryOnlyMode();
    SetMaxSize(100 * 1024);
    InitCache();
    ReuseEntry(10 * 1024, 0);
}

// Reading somewhere that was not written should return zeros.
void DiskCacheEntryTest::InvalidData(int stream_index)
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize1 = 20000;
    const int kSize2 = 20000;
    const int kSize3 = 20000;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
    scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3));

    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    memset(buffer2->data(), 0, kSize2);

    // Simple data grow:
    EXPECT_EQ(200,
        WriteData(entry, stream_index, 400, buffer1.get(), 200, false));
    EXPECT_EQ(600, entry->GetDataSize(stream_index));
    EXPECT_EQ(100, ReadData(entry, stream_index, 300, buffer3.get(), 100));
    EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));

    // The entry is now on disk. Load it and extend it.
    EXPECT_EQ(200,
        WriteData(entry, stream_index, 800, buffer1.get(), 200, false));
    EXPECT_EQ(1000, entry->GetDataSize(stream_index));
    EXPECT_EQ(100, ReadData(entry, stream_index, 700, buffer3.get(), 100));
    EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));

    // This time using truncate.
    EXPECT_EQ(200,
        WriteData(entry, stream_index, 1800, buffer1.get(), 200, true));
    EXPECT_EQ(2000, entry->GetDataSize(stream_index));
    EXPECT_EQ(100, ReadData(entry, stream_index, 1500, buffer3.get(), 100));
    EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));

    // Go to an external file.
    EXPECT_EQ(200,
        WriteData(entry, stream_index, 19800, buffer1.get(), 200, false));
    EXPECT_EQ(20000, entry->GetDataSize(stream_index));
    EXPECT_EQ(4000, ReadData(entry, stream_index, 14000, buffer3.get(), 4000));
    EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 4000));

    // And back to an internal block.
    EXPECT_EQ(600,
        WriteData(entry, stream_index, 1000, buffer1.get(), 600, true));
    EXPECT_EQ(1600, entry->GetDataSize(stream_index));
    EXPECT_EQ(600, ReadData(entry, stream_index, 1000, buffer3.get(), 600));
    EXPECT_TRUE(!memcmp(buffer3->data(), buffer1->data(), 600));

    // Extend it again.
    EXPECT_EQ(600,
        WriteData(entry, stream_index, 2000, buffer1.get(), 600, false));
    EXPECT_EQ(2600, entry->GetDataSize(stream_index));
    EXPECT_EQ(200, ReadData(entry, stream_index, 1800, buffer3.get(), 200));
    EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));

    // And again (with truncation flag).
    EXPECT_EQ(600,
        WriteData(entry, stream_index, 3000, buffer1.get(), 600, true));
    EXPECT_EQ(3600, entry->GetDataSize(stream_index));
    EXPECT_EQ(200, ReadData(entry, stream_index, 2800, buffer3.get(), 200));
    EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));

    entry->Close();
}

TEST_F(DiskCacheEntryTest, InvalidData)
{
    InitCache();
    InvalidData(0);
}

TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer)
{
    InitCache();
    cache_impl_->SetFlags(disk_cache::kNoBuffering);
    InvalidData(0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData)
{
    SetMemoryOnlyMode();
    InitCache();
    InvalidData(0);
}

// Tests that the cache preserves the buffer of an IO operation.
void DiskCacheEntryTest::ReadWriteDestroyBuffer(int stream_index)
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 200;
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer->data(), kSize, false);

    net::TestCompletionCallback cb;
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->WriteData(
            stream_index, 0, buffer.get(), kSize, cb.callback(), false));

    // Release our reference to the buffer.
    buffer = NULL;
    EXPECT_EQ(kSize, cb.WaitForResult());

    // And now test with a Read().
    buffer = new net::IOBuffer(kSize);
    CacheTestFillBuffer(buffer->data(), kSize, false);

    EXPECT_EQ(
        net::ERR_IO_PENDING,
        entry->ReadData(stream_index, 0, buffer.get(), kSize, cb.callback()));
    buffer = NULL;
    EXPECT_EQ(kSize, cb.WaitForResult());

    entry->Close();
}

TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer)
{
    InitCache();
    ReadWriteDestroyBuffer(0);
}

void DiskCacheEntryTest::DoomNormalEntry()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Doom();
    entry->Close();

    const int kSize = 20000;
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer->data(), kSize, true);
    buffer->data()[19999] = '\0';

    key = buffer->data();
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false));
    EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false));
    entry->Doom();
    entry->Close();

    FlushQueueForTest();
    EXPECT_EQ(0, cache_->GetEntryCount());
}

TEST_F(DiskCacheEntryTest, DoomEntry)
{
    InitCache();
    DoomNormalEntry();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry)
{
    SetMemoryOnlyMode();
    InitCache();
    DoomNormalEntry();
}

// Tests dooming an entry that's linked to an open entry.
void DiskCacheEntryTest::DoomEntryNextToOpenEntry()
{
    disk_cache::Entry* entry1;
    disk_cache::Entry* entry2;
    ASSERT_EQ(net::OK, CreateEntry("fixed", &entry1));
    entry1->Close();
    ASSERT_EQ(net::OK, CreateEntry("foo", &entry1));
    entry1->Close();
    ASSERT_EQ(net::OK, CreateEntry("bar", &entry1));
    entry1->Close();

    ASSERT_EQ(net::OK, OpenEntry("foo", &entry1));
    ASSERT_EQ(net::OK, OpenEntry("bar", &entry2));
    entry2->Doom();
    entry2->Close();

    ASSERT_EQ(net::OK, OpenEntry("foo", &entry2));
    entry2->Doom();
    entry2->Close();
    entry1->Close();

    ASSERT_EQ(net::OK, OpenEntry("fixed", &entry1));
    entry1->Close();
}

TEST_F(DiskCacheEntryTest, DoomEntryNextToOpenEntry)
{
    InitCache();
    DoomEntryNextToOpenEntry();
}

TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry)
{
    SetNewEviction();
    InitCache();
    DoomEntryNextToOpenEntry();
}

TEST_F(DiskCacheEntryTest, AppCacheDoomEntryNextToOpenEntry)
{
    SetCacheType(net::APP_CACHE);
    InitCache();
    DoomEntryNextToOpenEntry();
}

// Verify that basic operations work as expected with doomed entries.
void DiskCacheEntryTest::DoomedEntry(int stream_index)
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Doom();

    FlushQueueForTest();
    EXPECT_EQ(0, cache_->GetEntryCount());
    Time initial = Time::Now();
    AddDelay();

    const int kSize1 = 2000;
    const int kSize2 = 2000;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    memset(buffer2->data(), 0, kSize2);

    EXPECT_EQ(2000,
        WriteData(entry, stream_index, 0, buffer1.get(), 2000, false));
    EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000));
    EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1));
    EXPECT_EQ(key, entry->GetKey());
    EXPECT_TRUE(initial < entry->GetLastModified());
    EXPECT_TRUE(initial < entry->GetLastUsed());

    entry->Close();
}

TEST_F(DiskCacheEntryTest, DoomedEntry)
{
    InitCache();
    DoomedEntry(0);
}

TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry)
{
    SetMemoryOnlyMode();
    InitCache();
    DoomedEntry(0);
}

// Tests that we discard entries if the data is missing.
TEST_F(DiskCacheEntryTest, MissingData)
{
    InitCache();

    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    // Write to an external file.
    const int kSize = 20000;
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer->data(), kSize, false);
    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
    entry->Close();
    FlushQueueForTest();

    disk_cache::Addr address(0x80000001);
    base::FilePath name = cache_impl_->GetFileName(address);
    EXPECT_TRUE(base::DeleteFile(name, false));

    // Attempt to read the data.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(net::ERR_FILE_NOT_FOUND,
        ReadData(entry, 0, 0, buffer.get(), kSize));
    entry->Close();

    // The entry should be gone.
    ASSERT_NE(net::OK, OpenEntry(key, &entry));
}

// Test that child entries in a memory cache backend are not visible from
// enumerations.
TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries)
{
    SetMemoryOnlyMode();
    InitCache();

    const int kSize = 4096;
    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf->data(), kSize, false);

    std::string key("the first key");
    disk_cache::Entry* parent_entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &parent_entry));

    // Writes to the parent entry.
    EXPECT_EQ(kSize,
        parent_entry->WriteSparseData(
            0, buf.get(), kSize, net::CompletionCallback()));

    // This write creates a child entry and writes to it.
    EXPECT_EQ(kSize,
        parent_entry->WriteSparseData(
            8192, buf.get(), kSize, net::CompletionCallback()));

    parent_entry->Close();

    // Perform the enumerations.
    std::unique_ptr<TestIterator> iter = CreateIterator();
    disk_cache::Entry* entry = NULL;
    int count = 0;
    while (iter->OpenNextEntry(&entry) == net::OK) {
        ASSERT_TRUE(entry != NULL);
        ++count;
        disk_cache::MemEntryImpl* mem_entry = reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
        EXPECT_EQ(disk_cache::MemEntryImpl::PARENT_ENTRY, mem_entry->type());
        mem_entry->Close();
    }
    EXPECT_EQ(1, count);
}

// Writes |buf_1| to offset and reads it back as |buf_2|.
void VerifySparseIO(disk_cache::Entry* entry,
    int64_t offset,
    net::IOBuffer* buf_1,
    int size,
    net::IOBuffer* buf_2)
{
    net::TestCompletionCallback cb;

    memset(buf_2->data(), 0, size);
    int ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
    EXPECT_EQ(0, cb.GetResult(ret));

    ret = entry->WriteSparseData(offset, buf_1, size, cb.callback());
    EXPECT_EQ(size, cb.GetResult(ret));

    ret = entry->ReadSparseData(offset, buf_2, size, cb.callback());
    EXPECT_EQ(size, cb.GetResult(ret));

    EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size));
}

// Reads |size| bytes from |entry| at |offset| and verifies that they are the
// same as the content of the provided |buffer|.
void VerifyContentSparseIO(disk_cache::Entry* entry,
    int64_t offset,
    char* buffer,
    int size)
{
    net::TestCompletionCallback cb;

    scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size));
    memset(buf_1->data(), 0, size);
    int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback());
    EXPECT_EQ(size, cb.GetResult(ret));
    EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
}

void DiskCacheEntryTest::BasicSparseIO()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 2048;
    scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf_1->data(), kSize, false);

    // Write at offset 0.
    VerifySparseIO(entry, 0, buf_1.get(), kSize, buf_2.get());

    // Write at offset 0x400000 (4 MB).
    VerifySparseIO(entry, 0x400000, buf_1.get(), kSize, buf_2.get());

    // Write at offset 0x800000000 (32 GB).
    VerifySparseIO(entry, 0x800000000LL, buf_1.get(), kSize, buf_2.get());

    entry->Close();

    // Check everything again.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
    VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize);
    VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize);
    entry->Close();
}

TEST_F(DiskCacheEntryTest, BasicSparseIO)
{
    InitCache();
    BasicSparseIO();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO)
{
    SetMemoryOnlyMode();
    InitCache();
    BasicSparseIO();
}

void DiskCacheEntryTest::HugeSparseIO()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    // Write 1.2 MB so that we cover multiple entries.
    const int kSize = 1200 * 1024;
    scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf_1->data(), kSize, false);

    // Write at offset 0x20F0000 (33 MB - 64 KB).
    VerifySparseIO(entry, 0x20F0000, buf_1.get(), kSize, buf_2.get());
    entry->Close();

    // Check it again.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize);
    entry->Close();
}

TEST_F(DiskCacheEntryTest, HugeSparseIO)
{
    InitCache();
    HugeSparseIO();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO)
{
    SetMemoryOnlyMode();
    InitCache();
    HugeSparseIO();
}

void DiskCacheEntryTest::GetAvailableRange()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 16 * 1024;
    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf->data(), kSize, false);

    // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
    EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));
    EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize));

    // We stop at the first empty block.
    int64_t start;
    net::TestCompletionCallback cb;
    int rv = entry->GetAvailableRange(
        0x20F0000, kSize * 2, &start, cb.callback());
    EXPECT_EQ(kSize, cb.GetResult(rv));
    EXPECT_EQ(0x20F0000, start);

    start = 0;
    rv = entry->GetAvailableRange(0, kSize, &start, cb.callback());
    EXPECT_EQ(0, cb.GetResult(rv));
    rv = entry->GetAvailableRange(
        0x20F0000 - kSize, kSize, &start, cb.callback());
    EXPECT_EQ(0, cb.GetResult(rv));
    rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback());
    EXPECT_EQ(kSize, cb.GetResult(rv));
    EXPECT_EQ(0x20F0000, start);

    // We should be able to Read based on the results of GetAvailableRange.
    start = -1;
    rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback());
    EXPECT_EQ(0, cb.GetResult(rv));
    rv = entry->ReadSparseData(start, buf.get(), kSize, cb.callback());
    EXPECT_EQ(0, cb.GetResult(rv));

    start = 0;
    rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback());
    EXPECT_EQ(0x2000, cb.GetResult(rv));
    EXPECT_EQ(0x20F2000, start);
    EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf.get(), kSize));

    // Make sure that we respect the |len| argument.
    start = 0;
    rv = entry->GetAvailableRange(
        0x20F0001 - kSize, kSize, &start, cb.callback());
    EXPECT_EQ(1, cb.GetResult(rv));
    EXPECT_EQ(0x20F0000, start);

    // Use very small ranges. Write at offset 50.
    const int kTinyLen = 10;
    EXPECT_EQ(kTinyLen, WriteSparseData(entry, 50, buf.get(), kTinyLen));

    start = -1;
    rv = entry->GetAvailableRange(kTinyLen * 2, kTinyLen, &start, cb.callback());
    EXPECT_EQ(0, cb.GetResult(rv));
    EXPECT_EQ(kTinyLen * 2, start);

    entry->Close();
}

TEST_F(DiskCacheEntryTest, GetAvailableRange)
{
    InitCache();
    GetAvailableRange();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange)
{
    SetMemoryOnlyMode();
    InitCache();
    GetAvailableRange();
}

// Tests that non-sequential writes that are not aligned with the minimum sparse
// data granularity (1024 bytes) do in fact result in dropped data.
TEST_F(DiskCacheEntryTest, SparseWriteDropped)
{
    InitCache();
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 180;
    scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf_1->data(), kSize, false);

    // Do small writes (180 bytes) that get increasingly close to a 1024-byte
    // boundary. All data should be dropped until a boundary is crossed, at which
    // point the data after the boundary is saved (at least for a while).
    int offset = 1024 - 500;
    int rv = 0;
    net::TestCompletionCallback cb;
    int64_t start;
    for (int i = 0; i < 5; i++) {
        // Check result of last GetAvailableRange.
        EXPECT_EQ(0, rv);

        rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback());
        EXPECT_EQ(kSize, cb.GetResult(rv));

        rv = entry->GetAvailableRange(offset - 100, kSize, &start, cb.callback());
        EXPECT_EQ(0, cb.GetResult(rv));

        rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
        rv = cb.GetResult(rv);
        if (!rv) {
            rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
            EXPECT_EQ(0, cb.GetResult(rv));
            rv = 0;
        }
        offset += 1024 * i + 100;
    }

    // The last write started 100 bytes below a bundary, so there should be 80
    // bytes after the boundary.
    EXPECT_EQ(80, rv);
    EXPECT_EQ(1024 * 7, start);
    rv = entry->ReadSparseData(start, buf_2.get(), kSize, cb.callback());
    EXPECT_EQ(80, cb.GetResult(rv));
    EXPECT_EQ(0, memcmp(buf_1.get()->data() + 100, buf_2.get()->data(), 80));

    // And even that part is dropped when another write changes the offset.
    offset = start;
    rv = entry->WriteSparseData(0, buf_1.get(), kSize, cb.callback());
    EXPECT_EQ(kSize, cb.GetResult(rv));

    rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
    EXPECT_EQ(0, cb.GetResult(rv));
    entry->Close();
}

// Tests that small sequential writes are not dropped.
TEST_F(DiskCacheEntryTest, SparseSquentialWriteNotDropped)
{
    InitCache();
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 180;
    scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf_1->data(), kSize, false);

    // Any starting offset is fine as long as it is 1024-bytes aligned.
    int rv = 0;
    net::TestCompletionCallback cb;
    int64_t start;
    int64_t offset = 1024 * 11;
    for (; offset < 20000; offset += kSize) {
        rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback());
        EXPECT_EQ(kSize, cb.GetResult(rv));

        rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
        EXPECT_EQ(kSize, cb.GetResult(rv));
        EXPECT_EQ(offset, start);

        rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
        EXPECT_EQ(kSize, cb.GetResult(rv));
        EXPECT_EQ(0, memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize));
    }

    entry->Close();
    FlushQueueForTest();

    // Verify again the last write made.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    offset -= kSize;
    rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback());
    EXPECT_EQ(kSize, cb.GetResult(rv));
    EXPECT_EQ(offset, start);

    rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback());
    EXPECT_EQ(kSize, cb.GetResult(rv));
    EXPECT_EQ(0, memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize));

    entry->Close();
}

void DiskCacheEntryTest::CouldBeSparse()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 16 * 1024;
    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf->data(), kSize, false);

    // Write at offset 0x20F0000 (33 MB - 64 KB).
    EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize));

    EXPECT_TRUE(entry->CouldBeSparse());
    entry->Close();

    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_TRUE(entry->CouldBeSparse());
    entry->Close();

    // Now verify a regular entry.
    key.assign("another key");
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_FALSE(entry->CouldBeSparse());

    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false));
    EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false));
    EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false));

    EXPECT_FALSE(entry->CouldBeSparse());
    entry->Close();

    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_FALSE(entry->CouldBeSparse());
    entry->Close();
}

TEST_F(DiskCacheEntryTest, CouldBeSparse)
{
    InitCache();
    CouldBeSparse();
}

TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse)
{
    SetMemoryOnlyMode();
    InitCache();
    CouldBeSparse();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO)
{
    SetMemoryOnlyMode();
    InitCache();

    const int kSize = 8192;
    scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf_1->data(), kSize, false);

    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    // This loop writes back to back starting from offset 0 and 9000.
    for (int i = 0; i < kSize; i += 1024) {
        scoped_refptr<net::WrappedIOBuffer> buf_3(
            new net::WrappedIOBuffer(buf_1->data() + i));
        VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get());
        VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get());
    }

    // Make sure we have data written.
    VerifyContentSparseIO(entry, 0, buf_1->data(), kSize);
    VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize);

    // This tests a large write that spans 3 entries from a misaligned offset.
    VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get());

    entry->Close();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange)
{
    SetMemoryOnlyMode();
    InitCache();

    const int kSize = 8192;
    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf->data(), kSize, false);

    disk_cache::Entry* entry;
    std::string key("the first key");
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    // Writes in the middle of an entry.
    EXPECT_EQ(
        1024,
        entry->WriteSparseData(0, buf.get(), 1024, net::CompletionCallback()));
    EXPECT_EQ(
        1024,
        entry->WriteSparseData(5120, buf.get(), 1024, net::CompletionCallback()));
    EXPECT_EQ(1024,
        entry->WriteSparseData(
            10000, buf.get(), 1024, net::CompletionCallback()));

    // Writes in the middle of an entry and spans 2 child entries.
    EXPECT_EQ(8192,
        entry->WriteSparseData(
            50000, buf.get(), 8192, net::CompletionCallback()));

    int64_t start;
    net::TestCompletionCallback cb;
    // Test that we stop at a discontinuous child at the second block.
    int rv = entry->GetAvailableRange(0, 10000, &start, cb.callback());
    EXPECT_EQ(1024, cb.GetResult(rv));
    EXPECT_EQ(0, start);

    // Test that number of bytes is reported correctly when we start from the
    // middle of a filled region.
    rv = entry->GetAvailableRange(512, 10000, &start, cb.callback());
    EXPECT_EQ(512, cb.GetResult(rv));
    EXPECT_EQ(512, start);

    // Test that we found bytes in the child of next block.
    rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback());
    EXPECT_EQ(1024, cb.GetResult(rv));
    EXPECT_EQ(5120, start);

    // Test that the desired length is respected. It starts within a filled
    // region.
    rv = entry->GetAvailableRange(5500, 512, &start, cb.callback());
    EXPECT_EQ(512, cb.GetResult(rv));
    EXPECT_EQ(5500, start);

    // Test that the desired length is respected. It starts before a filled
    // region.
    rv = entry->GetAvailableRange(5000, 620, &start, cb.callback());
    EXPECT_EQ(500, cb.GetResult(rv));
    EXPECT_EQ(5120, start);

    // Test that multiple blocks are scanned.
    rv = entry->GetAvailableRange(40000, 20000, &start, cb.callback());
    EXPECT_EQ(8192, cb.GetResult(rv));
    EXPECT_EQ(50000, start);

    entry->Close();
}

void DiskCacheEntryTest::UpdateSparseEntry()
{
    std::string key("the first key");
    disk_cache::Entry* entry1;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry1));

    const int kSize = 2048;
    scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf_1->data(), kSize, false);

    // Write at offset 0.
    VerifySparseIO(entry1, 0, buf_1.get(), kSize, buf_2.get());
    entry1->Close();

    // Write at offset 2048.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
    VerifySparseIO(entry1, 2048, buf_1.get(), kSize, buf_2.get());

    disk_cache::Entry* entry2;
    ASSERT_EQ(net::OK, CreateEntry("the second key", &entry2));

    entry1->Close();
    entry2->Close();
    FlushQueueForTest();
    if (memory_only_ || simple_cache_mode_)
        EXPECT_EQ(2, cache_->GetEntryCount());
    else
        EXPECT_EQ(3, cache_->GetEntryCount());
}

TEST_F(DiskCacheEntryTest, UpdateSparseEntry)
{
    SetCacheType(net::MEDIA_CACHE);
    InitCache();
    UpdateSparseEntry();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry)
{
    SetMemoryOnlyMode();
    SetCacheType(net::MEDIA_CACHE);
    InitCache();
    UpdateSparseEntry();
}

void DiskCacheEntryTest::DoomSparseEntry()
{
    std::string key1("the first key");
    std::string key2("the second key");
    disk_cache::Entry *entry1, *entry2;
    ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
    ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));

    const int kSize = 4 * 1024;
    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf->data(), kSize, false);

    int64_t offset = 1024;
    // Write to a bunch of ranges.
    for (int i = 0; i < 12; i++) {
        EXPECT_EQ(kSize, WriteSparseData(entry1, offset, buf.get(), kSize));
        // Keep the second map under the default size.
        if (i < 9)
            EXPECT_EQ(kSize, WriteSparseData(entry2, offset, buf.get(), kSize));

        offset *= 4;
    }

    if (memory_only_ || simple_cache_mode_)
        EXPECT_EQ(2, cache_->GetEntryCount());
    else
        EXPECT_EQ(15, cache_->GetEntryCount());

    // Doom the first entry while it's still open.
    entry1->Doom();
    entry1->Close();
    entry2->Close();

    // Doom the second entry after it's fully saved.
    EXPECT_EQ(net::OK, DoomEntry(key2));

    // Make sure we do all needed work. This may fail for entry2 if between Close
    // and DoomEntry the system decides to remove all traces of the file from the
    // system cache so we don't see that there is pending IO.
    base::RunLoop().RunUntilIdle();

    if (memory_only_) {
        EXPECT_EQ(0, cache_->GetEntryCount());
    } else {
        if (5 == cache_->GetEntryCount()) {
            // Most likely we are waiting for the result of reading the sparse info
            // (it's always async on Posix so it is easy to miss). Unfortunately we
            // don't have any signal to watch for so we can only wait.
            base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
            base::RunLoop().RunUntilIdle();
        }
        EXPECT_EQ(0, cache_->GetEntryCount());
    }
}

TEST_F(DiskCacheEntryTest, DoomSparseEntry)
{
    UseCurrentThread();
    InitCache();
    DoomSparseEntry();
}

TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry)
{
    SetMemoryOnlyMode();
    InitCache();
    DoomSparseEntry();
}

// A CompletionCallback wrapper that deletes the cache from within the callback.
// The way a CompletionCallback works means that all tasks (even new ones)
// are executed by the message loop before returning to the caller so the only
// way to simulate a race is to execute what we want on the callback.
class SparseTestCompletionCallback : public net::TestCompletionCallback {
public:
    explicit SparseTestCompletionCallback(
        std::unique_ptr<disk_cache::Backend> cache)
        : cache_(std::move(cache))
    {
    }

private:
    void SetResult(int result) override
    {
        cache_.reset();
        TestCompletionCallback::SetResult(result);
    }

    std::unique_ptr<disk_cache::Backend> cache_;
    DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
};

// Tests that we don't crash when the backend is deleted while we are working
// deleting the sub-entries of a sparse entry.
TEST_F(DiskCacheEntryTest, DoomSparseEntry2)
{
    UseCurrentThread();
    InitCache();
    std::string key("the key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 4 * 1024;
    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf->data(), kSize, false);

    int64_t offset = 1024;
    // Write to a bunch of ranges.
    for (int i = 0; i < 12; i++) {
        EXPECT_EQ(kSize,
            entry->WriteSparseData(
                offset, buf.get(), kSize, net::CompletionCallback()));
        offset *= 4;
    }
    EXPECT_EQ(9, cache_->GetEntryCount());

    entry->Close();
    disk_cache::Backend* cache = cache_.get();
    SparseTestCompletionCallback cb(std::move(cache_));
    int rv = cache->DoomEntry(key, cb.callback());
    EXPECT_EQ(net::ERR_IO_PENDING, rv);
    EXPECT_EQ(net::OK, cb.WaitForResult());
}

void DiskCacheEntryTest::PartialSparseEntry()
{
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    // We should be able to deal with IO that is not aligned to the block size
    // of a sparse entry, at least to write a big range without leaving holes.
    const int kSize = 4 * 1024;
    const int kSmallSize = 128;
    scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf1->data(), kSize, false);

    // The first write is just to extend the entry. The third write occupies
    // a 1KB block partially, it may not be written internally depending on the
    // implementation.
    EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1.get(), kSize));
    EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1.get(), kSize));
    EXPECT_EQ(kSmallSize,
        WriteSparseData(entry, 1080321, buf1.get(), kSmallSize));
    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));

    scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
    memset(buf2->data(), 0, kSize);
    EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2.get(), kSize));

    EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
    EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
    EXPECT_EQ(0, ReadSparseData(entry, 0, buf2.get(), kSize));

    // This read should not change anything.
    if (memory_only_ || simple_cache_mode_)
        EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2.get(), kSize));
    else
        EXPECT_EQ(0, ReadSparseData(entry, 24000, buf2.get(), kSize));

    EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize));
    EXPECT_EQ(0, ReadSparseData(entry, 99, buf2.get(), kSize));

    int rv;
    int64_t start;
    net::TestCompletionCallback cb;
    if (memory_only_ || simple_cache_mode_) {
        rv = entry->GetAvailableRange(0, 600, &start, cb.callback());
        EXPECT_EQ(100, cb.GetResult(rv));
        EXPECT_EQ(500, start);
    } else {
        rv = entry->GetAvailableRange(0, 2048, &start, cb.callback());
        EXPECT_EQ(1024, cb.GetResult(rv));
        EXPECT_EQ(1024, start);
    }
    rv = entry->GetAvailableRange(kSize, kSize, &start, cb.callback());
    EXPECT_EQ(500, cb.GetResult(rv));
    EXPECT_EQ(kSize, start);
    rv = entry->GetAvailableRange(20 * 1024, 10000, &start, cb.callback());
    if (memory_only_ || simple_cache_mode_)
        EXPECT_EQ(3616, cb.GetResult(rv));
    else
        EXPECT_EQ(3072, cb.GetResult(rv));

    EXPECT_EQ(20 * 1024, start);

    // 1. Query before a filled 1KB block.
    // 2. Query within a filled 1KB block.
    // 3. Query beyond a filled 1KB block.
    if (memory_only_ || simple_cache_mode_) {
        rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback());
        EXPECT_EQ(3496, cb.GetResult(rv));
        EXPECT_EQ(20000, start);
    } else {
        rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback());
        EXPECT_EQ(3016, cb.GetResult(rv));
        EXPECT_EQ(20480, start);
    }
    rv = entry->GetAvailableRange(3073, kSize, &start, cb.callback());
    EXPECT_EQ(1523, cb.GetResult(rv));
    EXPECT_EQ(3073, start);
    rv = entry->GetAvailableRange(4600, kSize, &start, cb.callback());
    EXPECT_EQ(0, cb.GetResult(rv));
    EXPECT_EQ(4600, start);

    // Now make another write and verify that there is no hole in between.
    EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1.get(), kSize));
    rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback());
    EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv));
    EXPECT_EQ(1024, start);
    EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2.get(), kSize));
    EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
    EXPECT_EQ(0, memcmp(buf2->data() + 500, buf1->data(), kSize - 500));

    entry->Close();
}

TEST_F(DiskCacheEntryTest, PartialSparseEntry)
{
    InitCache();
    PartialSparseEntry();
}

TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry)
{
    SetMemoryOnlyMode();
    InitCache();
    PartialSparseEntry();
}

// Tests that corrupt sparse children are removed automatically.
TEST_F(DiskCacheEntryTest, CleanupSparseEntry)
{
    InitCache();
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 4 * 1024;
    scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf1->data(), kSize, false);

    const int k1Meg = 1024 * 1024;
    EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize));
    EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
    EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
    entry->Close();
    EXPECT_EQ(4, cache_->GetEntryCount());

    std::unique_ptr<TestIterator> iter = CreateIterator();
    int count = 0;
    std::string child_key[2];
    while (iter->OpenNextEntry(&entry) == net::OK) {
        ASSERT_TRUE(entry != NULL);
        // Writing to an entry will alter the LRU list and invalidate the iterator.
        if (entry->GetKey() != key && count < 2)
            child_key[count++] = entry->GetKey();
        entry->Close();
    }
    for (int i = 0; i < 2; i++) {
        ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry));
        // Overwrite the header's magic and signature.
        EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false));
        entry->Close();
    }

    EXPECT_EQ(4, cache_->GetEntryCount());
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));

    // Two children should be gone. One while reading and one while writing.
    EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
    EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1.get(), kSize));
    EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1.get(), kSize));

    // We never touched this one.
    EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1.get(), kSize));
    entry->Close();

    // We re-created one of the corrupt children.
    EXPECT_EQ(3, cache_->GetEntryCount());
}

TEST_F(DiskCacheEntryTest, CancelSparseIO)
{
    UseCurrentThread();
    InitCache();
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const int kSize = 40 * 1024;
    scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buf->data(), kSize, false);

    // This will open and write two "real" entries.
    net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
    int rv = entry->WriteSparseData(
        1024 * 1024 - 4096, buf.get(), kSize, cb1.callback());
    EXPECT_EQ(net::ERR_IO_PENDING, rv);

    int64_t offset = 0;
    rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
    rv = cb5.GetResult(rv);
    if (!cb1.have_result()) {
        // We may or may not have finished writing to the entry. If we have not,
        // we cannot start another operation at this time.
        EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, rv);
    }

    // We cancel the pending operation, and register multiple notifications.
    entry->CancelSparseIO();
    EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb2.callback()));
    EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb3.callback()));
    entry->CancelSparseIO(); // Should be a no op at this point.
    EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb4.callback()));

    if (!cb1.have_result()) {
        EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
            entry->ReadSparseData(
                offset, buf.get(), kSize, net::CompletionCallback()));
        EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
            entry->WriteSparseData(
                offset, buf.get(), kSize, net::CompletionCallback()));
    }

    // Now see if we receive all notifications. Note that we should not be able
    // to write everything (unless the timing of the system is really weird).
    rv = cb1.WaitForResult();
    EXPECT_TRUE(rv == 4096 || rv == kSize);
    EXPECT_EQ(net::OK, cb2.WaitForResult());
    EXPECT_EQ(net::OK, cb3.WaitForResult());
    EXPECT_EQ(net::OK, cb4.WaitForResult());

    rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback());
    EXPECT_EQ(0, cb5.GetResult(rv));
    entry->Close();
}

// Tests that we perform sanity checks on an entry's key. Note that there are
// other tests that exercise sanity checks by using saved corrupt files.
TEST_F(DiskCacheEntryTest, KeySanityCheck)
{
    UseCurrentThread();
    InitCache();
    std::string key("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    disk_cache::EntryImpl* entry_impl = static_cast<disk_cache::EntryImpl*>(entry);
    disk_cache::EntryStore* store = entry_impl->entry()->Data();

    // We have reserved space for a short key (one block), let's say that the key
    // takes more than one block, and remove the NULLs after the actual key.
    store->key_len = 800;
    memset(store->key + key.size(), 'k', sizeof(store->key) - key.size());
    entry_impl->entry()->set_modified();
    entry->Close();

    // We have a corrupt entry. Now reload it. We should NOT read beyond the
    // allocated buffer here.
    ASSERT_NE(net::OK, OpenEntry(key, &entry));
    DisableIntegrityCheck();
}

TEST_F(DiskCacheEntryTest, SimpleCacheInternalAsyncIO)
{
    SetSimpleCacheMode();
    InitCache();
    InternalAsyncIO();
}

TEST_F(DiskCacheEntryTest, SimpleCacheExternalAsyncIO)
{
    SetSimpleCacheMode();
    InitCache();
    ExternalAsyncIO();
}

TEST_F(DiskCacheEntryTest, SimpleCacheReleaseBuffer)
{
    SetSimpleCacheMode();
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        ReleaseBuffer(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheStreamAccess)
{
    SetSimpleCacheMode();
    InitCache();
    StreamAccess();
}

TEST_F(DiskCacheEntryTest, SimpleCacheGetKey)
{
    SetSimpleCacheMode();
    InitCache();
    GetKey();
}

TEST_F(DiskCacheEntryTest, SimpleCacheGetTimes)
{
    SetSimpleCacheMode();
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        GetTimes(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheGrowData)
{
    SetSimpleCacheMode();
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        GrowData(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheTruncateData)
{
    SetSimpleCacheMode();
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        TruncateData(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheZeroLengthIO)
{
    SetSimpleCacheMode();
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        ZeroLengthIO(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheSizeAtCreate)
{
    SetSimpleCacheMode();
    InitCache();
    SizeAtCreate();
}

TEST_F(DiskCacheEntryTest, SimpleCacheReuseExternalEntry)
{
    SetSimpleCacheMode();
    SetMaxSize(200 * 1024);
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        ReuseEntry(20 * 1024, i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheReuseInternalEntry)
{
    SetSimpleCacheMode();
    SetMaxSize(100 * 1024);
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        ReuseEntry(10 * 1024, i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheSizeChanges)
{
    SetSimpleCacheMode();
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        SizeChanges(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheInvalidData)
{
    SetSimpleCacheMode();
    InitCache();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        InvalidData(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheReadWriteDestroyBuffer)
{
    // Proving that the test works well with optimistic operations enabled is
    // subtle, instead run only in APP_CACHE mode to disable optimistic
    // operations. Stream 0 always uses optimistic operations, so the test is not
    // run on stream 0.
    SetCacheType(net::APP_CACHE);
    SetSimpleCacheMode();
    InitCache();
    for (int i = 1; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        ReadWriteDestroyBuffer(i);
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntry)
{
    SetSimpleCacheMode();
    InitCache();
    DoomNormalEntry();
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntryNextToOpenEntry)
{
    SetSimpleCacheMode();
    InitCache();
    DoomEntryNextToOpenEntry();
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomedEntry)
{
    SetSimpleCacheMode();
    InitCache();
    // Stream 2 is excluded because the implementation does not support writing to
    // it on a doomed entry, if it was previously lazily omitted.
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount - 1; ++i) {
        EXPECT_EQ(net::OK, DoomAllEntries());
        DoomedEntry(i);
    }
}

// Creates an entry with corrupted last byte in stream 0.
// Requires SimpleCacheMode.
bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const std::string& key,
    int* data_size)
{
    disk_cache::Entry* entry = NULL;

    if (CreateEntry(key, &entry) != net::OK || !entry) {
        LOG(ERROR) << "Could not create entry";
        return false;
    }

    const char data[] = "this is very good data";
    const int kDataSize = arraysize(data);
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kDataSize));
    base::strlcpy(buffer->data(), data, kDataSize);

    EXPECT_EQ(kDataSize, WriteData(entry, 1, 0, buffer.get(), kDataSize, false));
    entry->Close();
    entry = NULL;

    // Corrupt the last byte of the data.
    base::FilePath entry_file0_path = cache_path_.AppendASCII(
        disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
    base::File entry_file0(entry_file0_path,
        base::File::FLAG_WRITE | base::File::FLAG_OPEN);
    if (!entry_file0.IsValid())
        return false;

    int64_t file_offset = sizeof(disk_cache::SimpleFileHeader) + key.size() + kDataSize - 2;
    EXPECT_EQ(1, entry_file0.Write(file_offset, "X", 1));
    *data_size = kDataSize;
    return true;
}

// Tests that the simple cache can detect entries that have bad data.
TEST_F(DiskCacheEntryTest, SimpleCacheBadChecksum)
{
    SetSimpleCacheMode();
    InitCache();

    const char key[] = "the first key";
    int size_unused;
    ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));

    disk_cache::Entry* entry = NULL;

    // Open the entry.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    ScopedEntryPtr entry_closer(entry);

    const int kReadBufferSize = 200;
    EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
    scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
    EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
        ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
}

// Tests that an entry that has had an IO error occur can still be Doomed().
TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom)
{
    SetSimpleCacheMode();
    InitCache();

    const char key[] = "the first key";
    int size_unused;
    ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));

    disk_cache::Entry* entry = NULL;

    // Open the entry, forcing an IO error.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    ScopedEntryPtr entry_closer(entry);

    const int kReadBufferSize = 200;
    EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
    scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
    EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
        ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));

    entry->Doom(); // Should not crash.
}

bool TruncatePath(const base::FilePath& file_path, int64_t length)
{
    base::File file(file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN);
    if (!file.IsValid())
        return false;
    return file.SetLength(length);
}

TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF)
{
    SetSimpleCacheMode();
    InitCache();

    const std::string key("the first key");

    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    disk_cache::Entry* null = NULL;
    EXPECT_NE(null, entry);
    entry->Close();
    entry = NULL;

    // Force the entry to flush to disk, so subsequent platform file operations
    // succed.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    entry->Close();
    entry = NULL;

    // Truncate the file such that the length isn't sufficient to have an EOF
    // record.
    int kTruncationBytes = -static_cast<int>(sizeof(disk_cache::SimpleFileEOF));
    const base::FilePath entry_path = cache_path_.AppendASCII(
        disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
    const int64_t invalid_size = disk_cache::simple_util::GetFileSizeFromDataSize(
        key.size(), kTruncationBytes);
    EXPECT_TRUE(TruncatePath(entry_path, invalid_size));
    EXPECT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
    DisableIntegrityCheck();
}

TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsBasic)
{
    // Test sequence:
    // Create, Write, Read, Close.
    SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* const null_entry = NULL;

    disk_cache::Entry* entry = NULL;
    EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
    ASSERT_NE(null_entry, entry);
    ScopedEntryPtr entry_closer(entry);

    const int kBufferSize = 10;
    scoped_refptr<net::IOBufferWithSize> write_buffer(
        new net::IOBufferWithSize(kBufferSize));
    CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
    EXPECT_EQ(
        write_buffer->size(),
        WriteData(entry, 1, 0, write_buffer.get(), write_buffer->size(), false));

    scoped_refptr<net::IOBufferWithSize> read_buffer(
        new net::IOBufferWithSize(kBufferSize));
    EXPECT_EQ(read_buffer->size(),
        ReadData(entry, 1, 0, read_buffer.get(), read_buffer->size()));
}

TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsDontBlock)
{
    // Test sequence:
    // Create, Write, Close.
    SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* const null_entry = NULL;

    MessageLoopHelper helper;
    CallbackTest create_callback(&helper, false);

    int expected_callback_runs = 0;
    const int kBufferSize = 10;
    scoped_refptr<net::IOBufferWithSize> write_buffer(
        new net::IOBufferWithSize(kBufferSize));

    disk_cache::Entry* entry = NULL;
    EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
    ASSERT_NE(null_entry, entry);
    ScopedEntryPtr entry_closer(entry);

    CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
    CallbackTest write_callback(&helper, false);
    int ret = entry->WriteData(
        1,
        0,
        write_buffer.get(),
        write_buffer->size(),
        base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
        false);
    ASSERT_EQ(net::ERR_IO_PENDING, ret);
    helper.WaitUntilCacheIoFinished(++expected_callback_runs);
}

TEST_F(DiskCacheEntryTest,
    SimpleCacheNonOptimisticOperationsBasicsWithoutWaiting)
{
    // Test sequence:
    // Create, Write, Read, Close.
    SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* const null_entry = NULL;
    MessageLoopHelper helper;

    disk_cache::Entry* entry = NULL;
    // Note that |entry| is only set once CreateEntry() completed which is why we
    // have to wait (i.e. use the helper CreateEntry() function).
    EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
    ASSERT_NE(null_entry, entry);
    ScopedEntryPtr entry_closer(entry);

    const int kBufferSize = 10;
    scoped_refptr<net::IOBufferWithSize> write_buffer(
        new net::IOBufferWithSize(kBufferSize));
    CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
    CallbackTest write_callback(&helper, false);
    int ret = entry->WriteData(
        1,
        0,
        write_buffer.get(),
        write_buffer->size(),
        base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
        false);
    EXPECT_EQ(net::ERR_IO_PENDING, ret);
    int expected_callback_runs = 1;

    scoped_refptr<net::IOBufferWithSize> read_buffer(
        new net::IOBufferWithSize(kBufferSize));
    CallbackTest read_callback(&helper, false);
    ret = entry->ReadData(
        1,
        0,
        read_buffer.get(),
        read_buffer->size(),
        base::Bind(&CallbackTest::Run, base::Unretained(&read_callback)));
    EXPECT_EQ(net::ERR_IO_PENDING, ret);
    ++expected_callback_runs;

    helper.WaitUntilCacheIoFinished(expected_callback_runs);
    ASSERT_EQ(read_buffer->size(), write_buffer->size());
    EXPECT_EQ(
        0,
        memcmp(read_buffer->data(), write_buffer->data(), read_buffer->size()));
}

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic)
{
    // Test sequence:
    // Create, Write, Read, Write, Read, Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    MessageLoopHelper helper;
    CallbackTest callback1(&helper, false);
    CallbackTest callback2(&helper, false);
    CallbackTest callback3(&helper, false);
    CallbackTest callback4(&helper, false);
    CallbackTest callback5(&helper, false);

    int expected = 0;
    const int kSize1 = 10;
    const int kSize2 = 20;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2));
    scoped_refptr<net::IOBuffer> buffer2_read(new net::IOBuffer(kSize2));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    CacheTestFillBuffer(buffer2->data(), kSize2, false);

    disk_cache::Entry* entry = NULL;
    // Create is optimistic, must return OK.
    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry,
            base::Bind(&CallbackTest::Run,
                base::Unretained(&callback1))));
    EXPECT_NE(null, entry);
    ScopedEntryPtr entry_closer(entry);

    // This write may or may not be optimistic (it depends if the previous
    // optimistic create already finished by the time we call the write here).
    int ret = entry->WriteData(
        1,
        0,
        buffer1.get(),
        kSize1,
        base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
        false);
    EXPECT_TRUE(kSize1 == ret || net::ERR_IO_PENDING == ret);
    if (net::ERR_IO_PENDING == ret)
        expected++;

    // This Read must not be optimistic, since we don't support that yet.
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->ReadData(
            1,
            0,
            buffer1_read.get(),
            kSize1,
            base::Bind(&CallbackTest::Run, base::Unretained(&callback3))));
    expected++;
    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));

    // At this point after waiting, the pending operations queue on the entry
    // should be empty, so the next Write operation must run as optimistic.
    EXPECT_EQ(kSize2,
        entry->WriteData(
            1,
            0,
            buffer2.get(),
            kSize2,
            base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
            false));

    // Lets do another read so we block until both the write and the read
    // operation finishes and we can then test for HasOneRef() below.
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->ReadData(
            1,
            0,
            buffer2_read.get(),
            kSize2,
            base::Bind(&CallbackTest::Run, base::Unretained(&callback5))));
    expected++;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_EQ(0, memcmp(buffer2->data(), buffer2_read->data(), kSize2));

    // Check that we are not leaking.
    EXPECT_NE(entry, null);
    EXPECT_TRUE(
        static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
}

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2)
{
    // Test sequence:
    // Create, Open, Close, Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    MessageLoopHelper helper;
    CallbackTest callback1(&helper, false);
    CallbackTest callback2(&helper, false);

    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry,
            base::Bind(&CallbackTest::Run,
                base::Unretained(&callback1))));
    EXPECT_NE(null, entry);
    ScopedEntryPtr entry_closer(entry);

    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::ERR_IO_PENDING,
        cache_->OpenEntry(key, &entry2,
            base::Bind(&CallbackTest::Run,
                base::Unretained(&callback2))));
    ASSERT_TRUE(helper.WaitUntilCacheIoFinished(1));

    EXPECT_NE(null, entry2);
    EXPECT_EQ(entry, entry2);

    // We have to call close twice, since we called create and open above.
    entry->Close();

    // Check that we are not leaking.
    EXPECT_TRUE(
        static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
}

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic3)
{
    // Test sequence:
    // Create, Close, Open, Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry, net::CompletionCallback()));
    EXPECT_NE(null, entry);
    entry->Close();

    net::TestCompletionCallback cb;
    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::ERR_IO_PENDING,
        cache_->OpenEntry(key, &entry2, cb.callback()));
    ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
    ScopedEntryPtr entry_closer(entry2);

    EXPECT_NE(null, entry2);
    EXPECT_EQ(entry, entry2);

    // Check that we are not leaking.
    EXPECT_TRUE(
        static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
}

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4)
{
    // Test sequence:
    // Create, Close, Write, Open, Open, Close, Write, Read, Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    net::TestCompletionCallback cb;
    const int kSize1 = 10;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    disk_cache::Entry* entry = NULL;

    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry, net::CompletionCallback()));
    EXPECT_NE(null, entry);
    entry->Close();

    // Lets do a Write so we block until both the Close and the Write
    // operation finishes. Write must fail since we are writing in a closed entry.
    EXPECT_EQ(
        net::ERR_IO_PENDING,
        entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
    EXPECT_EQ(net::ERR_FAILED, cb.GetResult(net::ERR_IO_PENDING));

    // Finish running the pending tasks so that we fully complete the close
    // operation and destroy the entry object.
    base::RunLoop().RunUntilIdle();

    // At this point the |entry| must have been destroyed, and called
    // RemoveSelfFromBackend().
    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::ERR_IO_PENDING,
        cache_->OpenEntry(key, &entry2, cb.callback()));
    ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
    EXPECT_NE(null, entry2);

    disk_cache::Entry* entry3 = NULL;
    ASSERT_EQ(net::ERR_IO_PENDING,
        cache_->OpenEntry(key, &entry3, cb.callback()));
    ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
    EXPECT_NE(null, entry3);
    EXPECT_EQ(entry2, entry3);
    entry3->Close();

    // The previous Close doesn't actually closes the entry since we opened it
    // twice, so the next Write operation must succeed and it must be able to
    // perform it optimistically, since there is no operation running on this
    // entry.
    EXPECT_EQ(kSize1,
        entry2->WriteData(
            1, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));

    // Lets do another read so we block until both the write and the read
    // operation finishes and we can then test for HasOneRef() below.
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry2->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
    EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));

    // Check that we are not leaking.
    EXPECT_TRUE(
        static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
    entry2->Close();
}

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic5)
{
    // Test sequence:
    // Create, Doom, Write, Read, Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    net::TestCompletionCallback cb;
    const int kSize1 = 10;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    disk_cache::Entry* entry = NULL;

    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry, net::CompletionCallback()));
    EXPECT_NE(null, entry);
    ScopedEntryPtr entry_closer(entry);
    entry->Doom();

    EXPECT_EQ(
        net::ERR_IO_PENDING,
        entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
    EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));

    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
    EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));

    // Check that we are not leaking.
    EXPECT_TRUE(
        static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
}

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6)
{
    // Test sequence:
    // Create, Write, Doom, Doom, Read, Doom, Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    net::TestCompletionCallback cb;
    const int kSize1 = 10;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    disk_cache::Entry* entry = NULL;

    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry, net::CompletionCallback()));
    EXPECT_NE(null, entry);
    ScopedEntryPtr entry_closer(entry);

    EXPECT_EQ(
        net::ERR_IO_PENDING,
        entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
    EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));

    entry->Doom();
    entry->Doom();

    // This Read must not be optimistic, since we don't support that yet.
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->ReadData(1, 0, buffer1_read.get(), kSize1, cb.callback()));
    EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
    EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));

    entry->Doom();
}

// Confirm that IO buffers are not referenced by the Simple Cache after a write
// completes.
TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticWriteReleases)
{
    SetSimpleCacheMode();
    InitCache();

    const char key[] = "the first key";
    disk_cache::Entry* entry = NULL;

    // First, an optimistic create.
    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry, net::CompletionCallback()));
    ASSERT_TRUE(entry);
    ScopedEntryPtr entry_closer(entry);

    const int kWriteSize = 512;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kWriteSize));
    EXPECT_TRUE(buffer1->HasOneRef());
    CacheTestFillBuffer(buffer1->data(), kWriteSize, false);

    // An optimistic write happens only when there is an empty queue of pending
    // operations. To ensure the queue is empty, we issue a write and wait until
    // it completes.
    EXPECT_EQ(kWriteSize,
        WriteData(entry, 1, 0, buffer1.get(), kWriteSize, false));
    EXPECT_TRUE(buffer1->HasOneRef());

    // Finally, we should perform an optimistic write and confirm that all
    // references to the IO buffer have been released.
    EXPECT_EQ(
        kWriteSize,
        entry->WriteData(
            1, 0, buffer1.get(), kWriteSize, net::CompletionCallback(), false));
    EXPECT_TRUE(buffer1->HasOneRef());
}

TEST_F(DiskCacheEntryTest, SimpleCacheCreateDoomRace)
{
    // Test sequence:
    // Create, Doom, Write, Close, Check files are not on disk anymore.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    net::TestCompletionCallback cb;
    const int kSize1 = 10;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
    CacheTestFillBuffer(buffer1->data(), kSize1, false);
    disk_cache::Entry* entry = NULL;

    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry, net::CompletionCallback()));
    EXPECT_NE(null, entry);

    EXPECT_EQ(net::ERR_IO_PENDING, cache_->DoomEntry(key, cb.callback()));
    EXPECT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));

    EXPECT_EQ(
        kSize1,
        entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));

    entry->Close();

    // Finish running the pending tasks so that we fully complete the close
    // operation and destroy the entry object.
    base::RunLoop().RunUntilIdle();

    for (int i = 0; i < disk_cache::kSimpleEntryFileCount; ++i) {
        base::FilePath entry_file_path = cache_path_.AppendASCII(
            disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, i));
        base::File::Info info;
        EXPECT_FALSE(base::GetFileInfo(entry_file_path, &info));
    }
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateRace)
{
    // This test runs as APP_CACHE to make operations more synchronous. Test
    // sequence:
    // Create, Doom, Create.
    SetCacheType(net::APP_CACHE);
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    net::TestCompletionCallback create_callback;

    disk_cache::Entry* entry1 = NULL;
    ASSERT_EQ(net::OK,
        create_callback.GetResult(
            cache_->CreateEntry(key, &entry1, create_callback.callback())));
    ScopedEntryPtr entry1_closer(entry1);
    EXPECT_NE(null, entry1);

    net::TestCompletionCallback doom_callback;
    EXPECT_EQ(net::ERR_IO_PENDING,
        cache_->DoomEntry(key, doom_callback.callback()));

    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::OK,
        create_callback.GetResult(
            cache_->CreateEntry(key, &entry2, create_callback.callback())));
    ScopedEntryPtr entry2_closer(entry2);
    EXPECT_EQ(net::OK, doom_callback.GetResult(net::ERR_IO_PENDING));
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomDoom)
{
    // Test sequence:
    // Create, Doom, Create, Doom (1st entry), Open.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;

    const char key[] = "the first key";

    disk_cache::Entry* entry1 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
    ScopedEntryPtr entry1_closer(entry1);
    EXPECT_NE(null, entry1);

    EXPECT_EQ(net::OK, DoomEntry(key));

    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
    ScopedEntryPtr entry2_closer(entry2);
    EXPECT_NE(null, entry2);

    // Redundantly dooming entry1 should not delete entry2.
    disk_cache::SimpleEntryImpl* simple_entry1 = static_cast<disk_cache::SimpleEntryImpl*>(entry1);
    net::TestCompletionCallback cb;
    EXPECT_EQ(net::OK,
        cb.GetResult(simple_entry1->DoomEntry(cb.callback())));

    disk_cache::Entry* entry3 = NULL;
    ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
    ScopedEntryPtr entry3_closer(entry3);
    EXPECT_NE(null, entry3);
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateDoom)
{
    // Test sequence:
    // Create, Doom, Create, Doom.
    SetSimpleCacheMode();
    InitCache();

    disk_cache::Entry* null = NULL;

    const char key[] = "the first key";

    disk_cache::Entry* entry1 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
    ScopedEntryPtr entry1_closer(entry1);
    EXPECT_NE(null, entry1);

    entry1->Doom();

    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
    ScopedEntryPtr entry2_closer(entry2);
    EXPECT_NE(null, entry2);

    entry2->Doom();

    // This test passes if it doesn't crash.
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCloseCreateCloseOpen)
{
    // Test sequence: Create, Doom, Close, Create, Close, Open.
    SetSimpleCacheMode();
    InitCache();

    disk_cache::Entry* null = NULL;

    const char key[] = "this is a key";

    disk_cache::Entry* entry1 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
    ScopedEntryPtr entry1_closer(entry1);
    EXPECT_NE(null, entry1);

    entry1->Doom();
    entry1_closer.reset();
    entry1 = NULL;

    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
    ScopedEntryPtr entry2_closer(entry2);
    EXPECT_NE(null, entry2);

    entry2_closer.reset();
    entry2 = NULL;

    disk_cache::Entry* entry3 = NULL;
    ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
    ScopedEntryPtr entry3_closer(entry3);
    EXPECT_NE(null, entry3);
}

// Checks that an optimistic Create would fail later on a racing Open.
TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticCreateFailsOnOpen)
{
    SetSimpleCacheMode();
    InitCache();

    // Create a corrupt file in place of a future entry. Optimistic create should
    // initially succeed, but realize later that creation failed.
    const std::string key = "the key";
    net::TestCompletionCallback cb;
    disk_cache::Entry* entry = NULL;
    disk_cache::Entry* entry2 = NULL;

    EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
        key, cache_path_));
    EXPECT_EQ(net::OK, cache_->CreateEntry(key, &entry, cb.callback()));
    ASSERT_TRUE(entry);
    ScopedEntryPtr entry_closer(entry);
    ASSERT_NE(net::OK, OpenEntry(key, &entry2));

    // Check that we are not leaking.
    EXPECT_TRUE(
        static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());

    DisableIntegrityCheck();
}

// Tests that old entries are evicted while new entries remain in the index.
// This test relies on non-mandatory properties of the simple Cache Backend:
// LRU eviction, specific values of high-watermark and low-watermark etc.
// When changing the eviction algorithm, the test will have to be re-engineered.
TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries)
{
    const int kMaxSize = 200 * 1024;
    const int kWriteSize = kMaxSize / 10;
    const int kNumExtraEntries = 12;
    SetSimpleCacheMode();
    SetMaxSize(kMaxSize);
    InitCache();

    std::string key1("the first key");
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kWriteSize));
    CacheTestFillBuffer(buffer->data(), kWriteSize, false);
    EXPECT_EQ(kWriteSize,
        WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
    entry->Close();
    AddDelay();

    std::string key2("the key prefix");
    for (int i = 0; i < kNumExtraEntries; i++) {
        if (i == kNumExtraEntries - 2) {
            // Create a distinct timestamp for the last two entries. These entries
            // will be checked for outliving the eviction.
            AddDelay();
        }
        ASSERT_EQ(net::OK, CreateEntry(key2 + base::IntToString(i), &entry));
        ScopedEntryPtr entry_closer(entry);
        EXPECT_EQ(kWriteSize,
            WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
    }

    // TODO(pasko): Find a way to wait for the eviction task(s) to finish by using
    // the internal knowledge about |SimpleBackendImpl|.
    ASSERT_NE(net::OK, OpenEntry(key1, &entry))
        << "Should have evicted the old entry";
    for (int i = 0; i < 2; i++) {
        int entry_no = kNumExtraEntries - i - 1;
        // Generally there is no guarantee that at this point the backround eviction
        // is finished. We are testing the positive case, i.e. when the eviction
        // never reaches this entry, should be non-flaky.
        ASSERT_EQ(net::OK, OpenEntry(key2 + base::IntToString(entry_no), &entry))
            << "Should not have evicted fresh entry " << entry_no;
        entry->Close();
    }
}

// Tests that if a read and a following in-flight truncate are both in progress
// simultaniously that they both can occur successfully. See
// http://crbug.com/239223
TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate)
{
    SetSimpleCacheMode();
    InitCache();

    const char key[] = "the first key";

    const int kBufferSize = 1024;
    scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
    CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);

    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    EXPECT_EQ(kBufferSize,
        WriteData(entry, 1, 0, write_buffer.get(), kBufferSize, false));
    entry->Close();
    entry = NULL;

    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    ScopedEntryPtr entry_closer(entry);

    MessageLoopHelper helper;
    int expected = 0;

    // Make a short read.
    const int kReadBufferSize = 512;
    scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
    CallbackTest read_callback(&helper, false);
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->ReadData(1,
            0,
            read_buffer.get(),
            kReadBufferSize,
            base::Bind(&CallbackTest::Run,
                base::Unretained(&read_callback))));
    ++expected;

    // Truncate the entry to the length of that read.
    scoped_refptr<net::IOBuffer>
        truncate_buffer(new net::IOBuffer(kReadBufferSize));
    CacheTestFillBuffer(truncate_buffer->data(), kReadBufferSize, false);
    CallbackTest truncate_callback(&helper, false);
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->WriteData(1,
            0,
            truncate_buffer.get(),
            kReadBufferSize,
            base::Bind(&CallbackTest::Run,
                base::Unretained(&truncate_callback)),
            true));
    ++expected;

    // Wait for both the read and truncation to finish, and confirm that both
    // succeeded.
    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_EQ(kReadBufferSize, read_callback.last_result());
    EXPECT_EQ(kReadBufferSize, truncate_callback.last_result());
    EXPECT_EQ(0,
        memcmp(write_buffer->data(), read_buffer->data(), kReadBufferSize));
}

// Tests that if a write and a read dependant on it are both in flight
// simultaneiously that they both can complete successfully without erroneous
// early returns. See http://crbug.com/239223
TEST_F(DiskCacheEntryTest, SimpleCacheInFlightRead)
{
    SetSimpleCacheMode();
    InitCache();

    const char key[] = "the first key";
    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK,
        cache_->CreateEntry(key, &entry, net::CompletionCallback()));
    ScopedEntryPtr entry_closer(entry);

    const int kBufferSize = 1024;
    scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
    CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);

    MessageLoopHelper helper;
    int expected = 0;

    CallbackTest write_callback(&helper, false);
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->WriteData(1,
            0,
            write_buffer.get(),
            kBufferSize,
            base::Bind(&CallbackTest::Run,
                base::Unretained(&write_callback)),
            true));
    ++expected;

    scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kBufferSize));
    CallbackTest read_callback(&helper, false);
    EXPECT_EQ(net::ERR_IO_PENDING,
        entry->ReadData(1,
            0,
            read_buffer.get(),
            kBufferSize,
            base::Bind(&CallbackTest::Run,
                base::Unretained(&read_callback))));
    ++expected;

    EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
    EXPECT_EQ(kBufferSize, write_callback.last_result());
    EXPECT_EQ(kBufferSize, read_callback.last_result());
    EXPECT_EQ(0, memcmp(write_buffer->data(), read_buffer->data(), kBufferSize));
}

TEST_F(DiskCacheEntryTest, SimpleCacheOpenCreateRaceWithNoIndex)
{
    SetSimpleCacheMode();
    DisableSimpleCacheWaitForIndex();
    DisableIntegrityCheck();
    InitCache();

    // Assume the index is not initialized, which is likely, since we are blocking
    // the IO thread from executing the index finalization step.
    disk_cache::Entry* entry1;
    net::TestCompletionCallback cb1;
    disk_cache::Entry* entry2;
    net::TestCompletionCallback cb2;
    int rv1 = cache_->OpenEntry("key", &entry1, cb1.callback());
    int rv2 = cache_->CreateEntry("key", &entry2, cb2.callback());

    EXPECT_EQ(net::ERR_FAILED, cb1.GetResult(rv1));
    ASSERT_EQ(net::OK, cb2.GetResult(rv2));
    entry2->Close();
}

// Checking one more scenario of overlapped reading of a bad entry.
// Differs from the |SimpleCacheMultipleReadersCheckCRC| only by the order of
// last two reads.
TEST_F(DiskCacheEntryTest, SimpleCacheMultipleReadersCheckCRC2)
{
    SetSimpleCacheMode();
    InitCache();

    const char key[] = "key";
    int size;
    ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size));

    scoped_refptr<net::IOBuffer> read_buffer1(new net::IOBuffer(size));
    scoped_refptr<net::IOBuffer> read_buffer2(new net::IOBuffer(size));

    // Advance the first reader a little.
    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    ScopedEntryPtr entry_closer(entry);
    EXPECT_EQ(1, ReadData(entry, 1, 0, read_buffer1.get(), 1));

    // Advance the 2nd reader by the same amount.
    disk_cache::Entry* entry2 = NULL;
    EXPECT_EQ(net::OK, OpenEntry(key, &entry2));
    ScopedEntryPtr entry2_closer(entry2);
    EXPECT_EQ(1, ReadData(entry2, 1, 0, read_buffer2.get(), 1));

    // Continue reading 1st.
    EXPECT_GT(0, ReadData(entry, 1, 1, read_buffer1.get(), size));

    // This read should fail as well because we have previous read failures.
    EXPECT_GT(0, ReadData(entry2, 1, 1, read_buffer2.get(), 1));
    DisableIntegrityCheck();
}

// Test if we can sequentially read each subset of the data until all the data
// is read, then the CRC is calculated correctly and the reads are successful.
TEST_F(DiskCacheEntryTest, SimpleCacheReadCombineCRC)
{
    // Test sequence:
    // Create, Write, Read (first half of data), Read (second half of data),
    // Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    const int kHalfSize = 200;
    const int kSize = 2 * kHalfSize;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kSize, false);
    disk_cache::Entry* entry = NULL;

    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_NE(null, entry);

    EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
    entry->Close();

    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::OK, OpenEntry(key, &entry2));
    EXPECT_EQ(entry, entry2);

    // Read the first half of the data.
    int offset = 0;
    int buf_len = kHalfSize;
    scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(buf_len));
    EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read1.get(), buf_len));
    EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), buf_len));

    // Read the second half of the data.
    offset = buf_len;
    buf_len = kHalfSize;
    scoped_refptr<net::IOBuffer> buffer1_read2(new net::IOBuffer(buf_len));
    EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read2.get(), buf_len));
    char* buffer1_data = buffer1->data() + offset;
    EXPECT_EQ(0, memcmp(buffer1_data, buffer1_read2->data(), buf_len));

    // Check that we are not leaking.
    EXPECT_NE(entry, null);
    EXPECT_TRUE(
        static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
    entry->Close();
    entry = NULL;
}

// Test if we can write the data not in sequence and read correctly. In
// this case the CRC will not be present.
TEST_F(DiskCacheEntryTest, SimpleCacheNonSequentialWrite)
{
    // Test sequence:
    // Create, Write (second half of data), Write (first half of data), Read,
    // Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    const int kHalfSize = 200;
    const int kSize = 2 * kHalfSize;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kSize, false);
    char* buffer1_data = buffer1->data() + kHalfSize;
    memcpy(buffer2->data(), buffer1_data, kHalfSize);

    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Close();
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        ASSERT_EQ(net::OK, OpenEntry(key, &entry));
        EXPECT_NE(null, entry);

        int offset = kHalfSize;
        int buf_len = kHalfSize;

        EXPECT_EQ(buf_len,
            WriteData(entry, i, offset, buffer2.get(), buf_len, false));
        offset = 0;
        buf_len = kHalfSize;
        EXPECT_EQ(buf_len,
            WriteData(entry, i, offset, buffer1.get(), buf_len, false));
        entry->Close();

        ASSERT_EQ(net::OK, OpenEntry(key, &entry));

        scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(kSize));
        EXPECT_EQ(kSize, ReadData(entry, i, 0, buffer1_read1.get(), kSize));
        EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kSize));
        // Check that we are not leaking.
        ASSERT_NE(entry, null);
        EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
        entry->Close();
    }
}

// Test that changing stream1 size does not affect stream0 (stream0 and stream1
// are stored in the same file in Simple Cache).
TEST_F(DiskCacheEntryTest, SimpleCacheStream1SizeChanges)
{
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* entry = NULL;
    const std::string key("the key");
    const int kSize = 100;
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer_read(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer->data(), kSize, false);

    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_TRUE(entry);

    // Write something into stream0.
    EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
    EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
    EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
    entry->Close();

    // Extend stream1.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    int stream1_size = 100;
    EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, false));
    EXPECT_EQ(stream1_size, entry->GetDataSize(1));
    entry->Close();

    // Check that stream0 data has not been modified and that the EOF record for
    // stream 0 contains a crc.
    // The entry needs to be reopened before checking the crc: Open will perform
    // the synchronization with the previous Close. This ensures the EOF records
    // have been written to disk before we attempt to read them independently.
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    base::FilePath entry_file0_path = cache_path_.AppendASCII(
        disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
    base::File entry_file0(entry_file0_path,
        base::File::FLAG_READ | base::File::FLAG_OPEN);
    ASSERT_TRUE(entry_file0.IsValid());

    int data_size[disk_cache::kSimpleEntryStreamCount] = { kSize, stream1_size, 0 };
    int sparse_data_size = 0;
    disk_cache::SimpleEntryStat entry_stat(
        base::Time::Now(), base::Time::Now(), data_size, sparse_data_size);
    int eof_offset = entry_stat.GetEOFOffsetInFile(key.size(), 0);
    disk_cache::SimpleFileEOF eof_record;
    ASSERT_EQ(static_cast<int>(sizeof(eof_record)),
        entry_file0.Read(eof_offset, reinterpret_cast<char*>(&eof_record),
            sizeof(eof_record)));
    EXPECT_EQ(disk_cache::kSimpleFinalMagicNumber, eof_record.final_magic_number);
    EXPECT_TRUE((eof_record.flags & disk_cache::SimpleFileEOF::FLAG_HAS_CRC32) == disk_cache::SimpleFileEOF::FLAG_HAS_CRC32);

    buffer_read = new net::IOBuffer(kSize);
    EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
    EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));

    // Shrink stream1.
    stream1_size = 50;
    EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, true));
    EXPECT_EQ(stream1_size, entry->GetDataSize(1));
    entry->Close();

    // Check that stream0 data has not been modified.
    buffer_read = new net::IOBuffer(kSize);
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
    EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
    entry->Close();
    entry = NULL;
}

// Test that writing within the range for which the crc has already been
// computed will properly invalidate the computed crc.
TEST_F(DiskCacheEntryTest, SimpleCacheCRCRewrite)
{
    // Test sequence:
    // Create, Write (big data), Write (small data in the middle), Close.
    // Open, Read (all), Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    const int kHalfSize = 200;
    const int kSize = 2 * kHalfSize;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kHalfSize));
    CacheTestFillBuffer(buffer1->data(), kSize, false);
    CacheTestFillBuffer(buffer2->data(), kHalfSize, false);

    disk_cache::Entry* entry = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_NE(null, entry);
    entry->Close();

    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        ASSERT_EQ(net::OK, OpenEntry(key, &entry));
        int offset = 0;
        int buf_len = kSize;

        EXPECT_EQ(buf_len,
            WriteData(entry, i, offset, buffer1.get(), buf_len, false));
        offset = kHalfSize;
        buf_len = kHalfSize;
        EXPECT_EQ(buf_len,
            WriteData(entry, i, offset, buffer2.get(), buf_len, false));
        entry->Close();

        ASSERT_EQ(net::OK, OpenEntry(key, &entry));

        scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(kSize));
        EXPECT_EQ(kSize, ReadData(entry, i, 0, buffer1_read1.get(), kSize));
        EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kHalfSize));
        EXPECT_EQ(
            0,
            memcmp(buffer2->data(), buffer1_read1->data() + kHalfSize, kHalfSize));

        entry->Close();
    }
}

bool DiskCacheEntryTest::SimpleCacheThirdStreamFileExists(const char* key)
{
    int third_stream_file_index = disk_cache::simple_util::GetFileIndexFromStreamIndex(2);
    base::FilePath third_stream_file_path = cache_path_.AppendASCII(
        disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(
            key, third_stream_file_index));
    return PathExists(third_stream_file_path);
}

void DiskCacheEntryTest::SyncDoomEntry(const char* key)
{
    net::TestCompletionCallback callback;
    cache_->DoomEntry(key, callback.callback());
    callback.WaitForResult();
}

// Check that a newly-created entry with no third-stream writes omits the
// third stream file.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream1)
{
    SetSimpleCacheMode();
    InitCache();

    const char key[] = "key";

    disk_cache::Entry* entry;

    // Create entry and close without writing: third stream file should be
    // omitted, since the stream is empty.
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Close();
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));

    SyncDoomEntry(key);
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
}

// Check that a newly-created entry with only a single zero-offset, zero-length
// write omits the third stream file.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream2)
{
    SetSimpleCacheMode();
    InitCache();

    const int kHalfSize = 8;
    const int kSize = kHalfSize * 2;
    const char key[] = "key";
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer->data(), kHalfSize, false);

    disk_cache::Entry* entry;

    // Create entry, write empty buffer to third stream, and close: third stream
    // should still be omitted, since the entry ignores writes that don't modify
    // data or change the length.
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_EQ(0, WriteData(entry, 2, 0, buffer.get(), 0, true));
    entry->Close();
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));

    SyncDoomEntry(key);
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
}

// Check that we can read back data written to the third stream.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream3)
{
    SetSimpleCacheMode();
    InitCache();

    const int kHalfSize = 8;
    const int kSize = kHalfSize * 2;
    const char key[] = "key";
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kHalfSize, false);

    disk_cache::Entry* entry;

    // Create entry, write data to third stream, and close: third stream should
    // not be omitted, since it contains data.  Re-open entry and ensure there
    // are that many bytes in the third stream.
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
    entry->Close();
    EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));

    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_EQ(kHalfSize, ReadData(entry, 2, 0, buffer2.get(), kSize));
    EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kHalfSize));
    entry->Close();
    EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));

    SyncDoomEntry(key);
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
}

// Check that we remove the third stream file upon opening an entry and finding
// the third stream empty.  (This is the upgrade path for entries written
// before the third stream was optional.)
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream4)
{
    SetSimpleCacheMode();
    InitCache();

    const int kHalfSize = 8;
    const int kSize = kHalfSize * 2;
    const char key[] = "key";
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kHalfSize, false);

    disk_cache::Entry* entry;

    // Create entry, write data to third stream, truncate third stream back to
    // empty, and close: third stream will not initially be omitted, since entry
    // creates the file when the first significant write comes in, and only
    // removes it on open if it is empty.  Reopen, ensure that the file is
    // deleted, and that there's no data in the third stream.
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_EQ(kHalfSize, WriteData(entry, 2, 0, buffer1.get(), kHalfSize, true));
    EXPECT_EQ(0, WriteData(entry, 2, 0, buffer1.get(), 0, true));
    entry->Close();
    EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));

    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
    EXPECT_EQ(0, ReadData(entry, 2, 0, buffer2.get(), kSize));
    entry->Close();
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));

    SyncDoomEntry(key);
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
}

// Check that we don't accidentally create the third stream file once the entry
// has been doomed.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream5)
{
    SetSimpleCacheMode();
    InitCache();

    const int kHalfSize = 8;
    const int kSize = kHalfSize * 2;
    const char key[] = "key";
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer->data(), kHalfSize, false);

    disk_cache::Entry* entry;

    // Create entry, doom entry, write data to third stream, and close: third
    // stream should not exist.  (Note: We don't care if the write fails, just
    // that it doesn't cause the file to be created on disk.)
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Doom();
    WriteData(entry, 2, 0, buffer.get(), kHalfSize, true);
    entry->Close();
    EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
}

// There could be a race between Doom and an optimistic write.
TEST_F(DiskCacheEntryTest, SimpleCacheDoomOptimisticWritesRace)
{
    // Test sequence:
    // Create, first Write, second Write, Close.
    // Open, Close.
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* null = NULL;
    const char key[] = "the first key";

    const int kSize = 200;
    scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
    scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer1->data(), kSize, false);
    CacheTestFillBuffer(buffer2->data(), kSize, false);

    // The race only happens on stream 1 and stream 2.
    for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) {
        ASSERT_EQ(net::OK, DoomAllEntries());
        disk_cache::Entry* entry = NULL;

        ASSERT_EQ(net::OK, CreateEntry(key, &entry));
        EXPECT_NE(null, entry);
        entry->Close();
        entry = NULL;

        ASSERT_EQ(net::OK, DoomAllEntries());
        ASSERT_EQ(net::OK, CreateEntry(key, &entry));
        EXPECT_NE(null, entry);

        int offset = 0;
        int buf_len = kSize;
        // This write should not be optimistic (since create is).
        EXPECT_EQ(buf_len,
            WriteData(entry, i, offset, buffer1.get(), buf_len, false));

        offset = kSize;
        // This write should be optimistic.
        EXPECT_EQ(buf_len,
            WriteData(entry, i, offset, buffer2.get(), buf_len, false));
        entry->Close();

        ASSERT_EQ(net::OK, OpenEntry(key, &entry));
        EXPECT_NE(null, entry);

        entry->Close();
        entry = NULL;
    }
}

// Tests for a regression in crbug.com/317138 , in which deleting an already
// doomed entry was removing the active entry from the index.
TEST_F(DiskCacheEntryTest, SimpleCachePreserveActiveEntries)
{
    SetSimpleCacheMode();
    InitCache();

    disk_cache::Entry* null = NULL;

    const char key[] = "this is a key";

    disk_cache::Entry* entry1 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
    ScopedEntryPtr entry1_closer(entry1);
    EXPECT_NE(null, entry1);
    entry1->Doom();

    disk_cache::Entry* entry2 = NULL;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry2));
    ScopedEntryPtr entry2_closer(entry2);
    EXPECT_NE(null, entry2);
    entry2_closer.reset();

    // Closing then reopening entry2 insures that entry2 is serialized, and so
    // it can be opened from files without error.
    entry2 = NULL;
    ASSERT_EQ(net::OK, OpenEntry(key, &entry2));
    EXPECT_NE(null, entry2);
    entry2_closer.reset(entry2);

    scoped_refptr<disk_cache::SimpleEntryImpl>
        entry1_refptr = static_cast<disk_cache::SimpleEntryImpl*>(entry1);

    // If crbug.com/317138 has regressed, this will remove |entry2| from
    // the backend's |active_entries_| while |entry2| is still alive and its
    // files are still on disk.
    entry1_closer.reset();
    entry1 = NULL;

    // Close does not have a callback. However, we need to be sure the close is
    // finished before we continue the test. We can take advantage of how the ref
    // counting of a SimpleEntryImpl works to fake out a callback: When the
    // last Close() call is made to an entry, an IO operation is sent to the
    // synchronous entry to close the platform files. This IO operation holds a
    // ref pointer to the entry, which expires when the operation is done. So,
    // we take a refpointer, and watch the SimpleEntry object until it has only
    // one ref; this indicates the IO operation is complete.
    while (!entry1_refptr->HasOneRef()) {
        base::PlatformThread::YieldCurrentThread();
        base::RunLoop().RunUntilIdle();
    }
    entry1_refptr = NULL;

    // In the bug case, this new entry ends up being a duplicate object pointing
    // at the same underlying files.
    disk_cache::Entry* entry3 = NULL;
    EXPECT_EQ(net::OK, OpenEntry(key, &entry3));
    ScopedEntryPtr entry3_closer(entry3);
    EXPECT_NE(null, entry3);

    // The test passes if these two dooms do not crash.
    entry2->Doom();
    entry3->Doom();
}

TEST_F(DiskCacheEntryTest, SimpleCacheBasicSparseIO)
{
    SetSimpleCacheMode();
    InitCache();
    BasicSparseIO();
}

TEST_F(DiskCacheEntryTest, SimpleCacheHugeSparseIO)
{
    SetSimpleCacheMode();
    InitCache();
    HugeSparseIO();
}

TEST_F(DiskCacheEntryTest, SimpleCacheGetAvailableRange)
{
    SetSimpleCacheMode();
    InitCache();
    GetAvailableRange();
}

TEST_F(DiskCacheEntryTest, SimpleCacheUpdateSparseEntry)
{
    SetSimpleCacheMode();
    InitCache();
    UpdateSparseEntry();
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoomSparseEntry)
{
    SetSimpleCacheMode();
    InitCache();
    DoomSparseEntry();
}

TEST_F(DiskCacheEntryTest, SimpleCachePartialSparseEntry)
{
    SetSimpleCacheMode();
    InitCache();
    PartialSparseEntry();
}

TEST_F(DiskCacheEntryTest, SimpleCacheTruncateLargeSparseFile)
{
    const int kSize = 1024;

    SetSimpleCacheMode();
    // An entry is allowed sparse data 1/10 the size of the cache, so this size
    // allows for one |kSize|-sized range plus overhead, but not two ranges.
    SetMaxSize(kSize * 15);
    InitCache();

    const char key[] = "key";
    disk_cache::Entry* null = NULL;
    disk_cache::Entry* entry;
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    EXPECT_NE(null, entry);

    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
    CacheTestFillBuffer(buffer->data(), kSize, false);
    net::TestCompletionCallback callback;
    int ret;

    // Verify initial conditions.
    ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(0, callback.GetResult(ret));

    ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(0, callback.GetResult(ret));

    // Write a range and make sure it reads back.
    ret = entry->WriteSparseData(0, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(kSize, callback.GetResult(ret));

    ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(kSize, callback.GetResult(ret));

    // Write another range and make sure it reads back.
    ret = entry->WriteSparseData(kSize, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(kSize, callback.GetResult(ret));

    ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(kSize, callback.GetResult(ret));

    // Make sure the first range was removed when the second was written.
    ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(0, callback.GetResult(ret));

    // Close and reopen the entry and make sure the first entry is still absent
    // and the second entry is still present.
    entry->Close();
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));

    ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(0, callback.GetResult(ret));

    ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
    EXPECT_EQ(kSize, callback.GetResult(ret));

    entry->Close();
}

TEST_F(DiskCacheEntryTest, SimpleCacheReadWithoutKeySHA256)
{
    // This test runs as APP_CACHE to make operations more synchronous.
    SetCacheType(net::APP_CACHE);
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* entry;
    std::string key("a key");
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));

    const std::string stream_0_data = "data for stream zero";
    scoped_refptr<net::IOBuffer> stream_0_iobuffer(
        new net::StringIOBuffer(stream_0_data));
    EXPECT_EQ(static_cast<int>(stream_0_data.size()),
        WriteData(entry, 0, 0, stream_0_iobuffer.get(),
            stream_0_data.size(), false));
    const std::string stream_1_data = "FOR STREAM ONE, QUITE DIFFERENT THINGS";
    scoped_refptr<net::IOBuffer> stream_1_iobuffer(
        new net::StringIOBuffer(stream_1_data));
    EXPECT_EQ(static_cast<int>(stream_1_data.size()),
        WriteData(entry, 1, 0, stream_1_iobuffer.get(),
            stream_1_data.size(), false));
    entry->Close();

    base::RunLoop().RunUntilIdle();
    disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
    base::RunLoop().RunUntilIdle();

    EXPECT_TRUE(
        disk_cache::simple_util::RemoveKeySHA256FromEntry(key, cache_path_));
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    ScopedEntryPtr entry_closer(entry);

    EXPECT_EQ(static_cast<int>(stream_0_data.size()), entry->GetDataSize(0));
    scoped_refptr<net::IOBuffer> check_stream_0_data(
        new net::IOBuffer(stream_0_data.size()));
    EXPECT_EQ(
        static_cast<int>(stream_0_data.size()),
        ReadData(entry, 0, 0, check_stream_0_data.get(), stream_0_data.size()));
    EXPECT_EQ(0, stream_0_data.compare(0, std::string::npos, check_stream_0_data->data(), stream_0_data.size()));

    EXPECT_EQ(static_cast<int>(stream_1_data.size()), entry->GetDataSize(1));
    scoped_refptr<net::IOBuffer> check_stream_1_data(
        new net::IOBuffer(stream_1_data.size()));
    EXPECT_EQ(
        static_cast<int>(stream_1_data.size()),
        ReadData(entry, 1, 0, check_stream_1_data.get(), stream_1_data.size()));
    EXPECT_EQ(0, stream_1_data.compare(0, std::string::npos, check_stream_1_data->data(), stream_1_data.size()));
}

TEST_F(DiskCacheEntryTest, SimpleCacheDoubleOpenWithoutKeySHA256)
{
    // This test runs as APP_CACHE to make operations more synchronous.
    SetCacheType(net::APP_CACHE);
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* entry;
    std::string key("a key");
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Close();

    base::RunLoop().RunUntilIdle();
    disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
    base::RunLoop().RunUntilIdle();

    EXPECT_TRUE(
        disk_cache::simple_util::RemoveKeySHA256FromEntry(key, cache_path_));
    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    entry->Close();

    base::RunLoop().RunUntilIdle();
    disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
    base::RunLoop().RunUntilIdle();

    ASSERT_EQ(net::OK, OpenEntry(key, &entry));
    entry->Close();
}

TEST_F(DiskCacheEntryTest, SimpleCacheReadCorruptKeySHA256)
{
    // This test runs as APP_CACHE to make operations more synchronous.
    SetCacheType(net::APP_CACHE);
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* entry;
    std::string key("a key");
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Close();

    base::RunLoop().RunUntilIdle();
    disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
    base::RunLoop().RunUntilIdle();

    EXPECT_TRUE(
        disk_cache::simple_util::CorruptKeySHA256FromEntry(key, cache_path_));
    EXPECT_NE(net::OK, OpenEntry(key, &entry));
}

TEST_F(DiskCacheEntryTest, SimpleCacheReadCorruptLength)
{
    SetCacheType(net::APP_CACHE);
    SetSimpleCacheMode();
    InitCache();
    disk_cache::Entry* entry;
    std::string key("a key");
    ASSERT_EQ(net::OK, CreateEntry(key, &entry));
    entry->Close();

    base::RunLoop().RunUntilIdle();
    disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
    base::RunLoop().RunUntilIdle();

    EXPECT_TRUE(
        disk_cache::simple_util::CorruptStream0LengthFromEntry(key, cache_path_));
    EXPECT_NE(net::OK, OpenEntry(key, &entry));
}
